1
14
15 package com.liferay.portal.service.persistence;
16
17 import com.liferay.portal.NoSuchAddressException;
18 import com.liferay.portal.NoSuchModelException;
19 import com.liferay.portal.SystemException;
20 import com.liferay.portal.kernel.annotation.BeanReference;
21 import com.liferay.portal.kernel.cache.CacheRegistry;
22 import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
23 import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
24 import com.liferay.portal.kernel.dao.orm.FinderPath;
25 import com.liferay.portal.kernel.dao.orm.Query;
26 import com.liferay.portal.kernel.dao.orm.QueryPos;
27 import com.liferay.portal.kernel.dao.orm.QueryUtil;
28 import com.liferay.portal.kernel.dao.orm.Session;
29 import com.liferay.portal.kernel.log.Log;
30 import com.liferay.portal.kernel.log.LogFactoryUtil;
31 import com.liferay.portal.kernel.util.GetterUtil;
32 import com.liferay.portal.kernel.util.InstanceFactory;
33 import com.liferay.portal.kernel.util.OrderByComparator;
34 import com.liferay.portal.kernel.util.StringBundler;
35 import com.liferay.portal.kernel.util.StringPool;
36 import com.liferay.portal.kernel.util.StringUtil;
37 import com.liferay.portal.model.Address;
38 import com.liferay.portal.model.ModelListener;
39 import com.liferay.portal.model.impl.AddressImpl;
40 import com.liferay.portal.model.impl.AddressModelImpl;
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 AddressPersistenceImpl extends BasePersistenceImpl<Address>
63 implements AddressPersistence {
64 public static final String FINDER_CLASS_NAME_ENTITY = AddressImpl.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(AddressModelImpl.ENTITY_CACHE_ENABLED,
68 AddressModelImpl.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(AddressModelImpl.ENTITY_CACHE_ENABLED,
77 AddressModelImpl.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(AddressModelImpl.ENTITY_CACHE_ENABLED,
80 AddressModelImpl.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(AddressModelImpl.ENTITY_CACHE_ENABLED,
89 AddressModelImpl.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(AddressModelImpl.ENTITY_CACHE_ENABLED,
92 AddressModelImpl.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(AddressModelImpl.ENTITY_CACHE_ENABLED,
101 AddressModelImpl.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(AddressModelImpl.ENTITY_CACHE_ENABLED,
105 AddressModelImpl.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(AddressModelImpl.ENTITY_CACHE_ENABLED,
114 AddressModelImpl.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_M = new FinderPath(AddressModelImpl.ENTITY_CACHE_ENABLED,
120 AddressModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
121 "findByC_C_C_M",
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_M = new FinderPath(AddressModelImpl.ENTITY_CACHE_ENABLED,
130 AddressModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
131 "countByC_C_C_M",
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_BY_C_C_C_P = new FinderPath(AddressModelImpl.ENTITY_CACHE_ENABLED,
137 AddressModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
138 "findByC_C_C_P",
139 new String[] {
140 Long.class.getName(), Long.class.getName(), Long.class.getName(),
141 Boolean.class.getName(),
142
143 "java.lang.Integer", "java.lang.Integer",
144 "com.liferay.portal.kernel.util.OrderByComparator"
145 });
146 public static final FinderPath FINDER_PATH_COUNT_BY_C_C_C_P = new FinderPath(AddressModelImpl.ENTITY_CACHE_ENABLED,
147 AddressModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
148 "countByC_C_C_P",
149 new String[] {
150 Long.class.getName(), Long.class.getName(), Long.class.getName(),
151 Boolean.class.getName()
152 });
153 public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(AddressModelImpl.ENTITY_CACHE_ENABLED,
154 AddressModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
155 "findAll", new String[0]);
156 public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(AddressModelImpl.ENTITY_CACHE_ENABLED,
157 AddressModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
158 "countAll", new String[0]);
159
160 public void cacheResult(Address address) {
161 EntityCacheUtil.putResult(AddressModelImpl.ENTITY_CACHE_ENABLED,
162 AddressImpl.class, address.getPrimaryKey(), address);
163 }
164
165 public void cacheResult(List<Address> addresses) {
166 for (Address address : addresses) {
167 if (EntityCacheUtil.getResult(
168 AddressModelImpl.ENTITY_CACHE_ENABLED,
169 AddressImpl.class, address.getPrimaryKey(), this) == null) {
170 cacheResult(address);
171 }
172 }
173 }
174
175 public void clearCache() {
176 CacheRegistry.clear(AddressImpl.class.getName());
177 EntityCacheUtil.clearCache(AddressImpl.class.getName());
178 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
179 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
180 }
181
182 public void clearCache(Address address) {
183 EntityCacheUtil.removeResult(AddressModelImpl.ENTITY_CACHE_ENABLED,
184 AddressImpl.class, address.getPrimaryKey());
185 }
186
187 public Address create(long addressId) {
188 Address address = new AddressImpl();
189
190 address.setNew(true);
191 address.setPrimaryKey(addressId);
192
193 return address;
194 }
195
196 public Address remove(Serializable primaryKey)
197 throws NoSuchModelException, SystemException {
198 return remove(((Long)primaryKey).longValue());
199 }
200
201 public Address remove(long addressId)
202 throws NoSuchAddressException, SystemException {
203 Session session = null;
204
205 try {
206 session = openSession();
207
208 Address address = (Address)session.get(AddressImpl.class,
209 new Long(addressId));
210
211 if (address == null) {
212 if (_log.isWarnEnabled()) {
213 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + addressId);
214 }
215
216 throw new NoSuchAddressException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
217 addressId);
218 }
219
220 return remove(address);
221 }
222 catch (NoSuchAddressException nsee) {
223 throw nsee;
224 }
225 catch (Exception e) {
226 throw processException(e);
227 }
228 finally {
229 closeSession(session);
230 }
231 }
232
233 protected Address removeImpl(Address address) throws SystemException {
234 address = toUnwrappedModel(address);
235
236 Session session = null;
237
238 try {
239 session = openSession();
240
241 BatchSessionUtil.delete(session, address);
242 }
243 catch (Exception e) {
244 throw processException(e);
245 }
246 finally {
247 closeSession(session);
248 }
249
250 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
251
252 EntityCacheUtil.removeResult(AddressModelImpl.ENTITY_CACHE_ENABLED,
253 AddressImpl.class, address.getPrimaryKey());
254
255 return address;
256 }
257
258
261 public Address update(Address address) throws SystemException {
262 if (_log.isWarnEnabled()) {
263 _log.warn(
264 "Using the deprecated update(Address address) method. Use update(Address address, boolean merge) instead.");
265 }
266
267 return update(address, false);
268 }
269
270 public Address updateImpl(com.liferay.portal.model.Address address,
271 boolean merge) throws SystemException {
272 address = toUnwrappedModel(address);
273
274 Session session = null;
275
276 try {
277 session = openSession();
278
279 BatchSessionUtil.update(session, address, merge);
280
281 address.setNew(false);
282 }
283 catch (Exception e) {
284 throw processException(e);
285 }
286 finally {
287 closeSession(session);
288 }
289
290 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
291
292 EntityCacheUtil.putResult(AddressModelImpl.ENTITY_CACHE_ENABLED,
293 AddressImpl.class, address.getPrimaryKey(), address);
294
295 return address;
296 }
297
298 protected Address toUnwrappedModel(Address address) {
299 if (address instanceof AddressImpl) {
300 return address;
301 }
302
303 AddressImpl addressImpl = new AddressImpl();
304
305 addressImpl.setNew(address.isNew());
306 addressImpl.setPrimaryKey(address.getPrimaryKey());
307
308 addressImpl.setAddressId(address.getAddressId());
309 addressImpl.setCompanyId(address.getCompanyId());
310 addressImpl.setUserId(address.getUserId());
311 addressImpl.setUserName(address.getUserName());
312 addressImpl.setCreateDate(address.getCreateDate());
313 addressImpl.setModifiedDate(address.getModifiedDate());
314 addressImpl.setClassNameId(address.getClassNameId());
315 addressImpl.setClassPK(address.getClassPK());
316 addressImpl.setStreet1(address.getStreet1());
317 addressImpl.setStreet2(address.getStreet2());
318 addressImpl.setStreet3(address.getStreet3());
319 addressImpl.setCity(address.getCity());
320 addressImpl.setZip(address.getZip());
321 addressImpl.setRegionId(address.getRegionId());
322 addressImpl.setCountryId(address.getCountryId());
323 addressImpl.setTypeId(address.getTypeId());
324 addressImpl.setMailing(address.isMailing());
325 addressImpl.setPrimary(address.isPrimary());
326
327 return addressImpl;
328 }
329
330 public Address findByPrimaryKey(Serializable primaryKey)
331 throws NoSuchModelException, SystemException {
332 return findByPrimaryKey(((Long)primaryKey).longValue());
333 }
334
335 public Address findByPrimaryKey(long addressId)
336 throws NoSuchAddressException, SystemException {
337 Address address = fetchByPrimaryKey(addressId);
338
339 if (address == null) {
340 if (_log.isWarnEnabled()) {
341 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + addressId);
342 }
343
344 throw new NoSuchAddressException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
345 addressId);
346 }
347
348 return address;
349 }
350
351 public Address fetchByPrimaryKey(Serializable primaryKey)
352 throws SystemException {
353 return fetchByPrimaryKey(((Long)primaryKey).longValue());
354 }
355
356 public Address fetchByPrimaryKey(long addressId) throws SystemException {
357 Address address = (Address)EntityCacheUtil.getResult(AddressModelImpl.ENTITY_CACHE_ENABLED,
358 AddressImpl.class, addressId, this);
359
360 if (address == null) {
361 Session session = null;
362
363 try {
364 session = openSession();
365
366 address = (Address)session.get(AddressImpl.class,
367 new Long(addressId));
368 }
369 catch (Exception e) {
370 throw processException(e);
371 }
372 finally {
373 if (address != null) {
374 cacheResult(address);
375 }
376
377 closeSession(session);
378 }
379 }
380
381 return address;
382 }
383
384 public List<Address> findByCompanyId(long companyId)
385 throws SystemException {
386 return findByCompanyId(companyId, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
387 null);
388 }
389
390 public List<Address> findByCompanyId(long companyId, int start, int end)
391 throws SystemException {
392 return findByCompanyId(companyId, start, end, null);
393 }
394
395 public List<Address> findByCompanyId(long companyId, int start, int end,
396 OrderByComparator orderByComparator) throws SystemException {
397 Object[] finderArgs = new Object[] {
398 companyId,
399
400 String.valueOf(start), String.valueOf(end),
401 String.valueOf(orderByComparator)
402 };
403
404 List<Address> list = (List<Address>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_COMPANYID,
405 finderArgs, this);
406
407 if (list == null) {
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_ADDRESS_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(AddressModelImpl.ORDER_BY_JPQL);
429 }
430
431 String sql = query.toString();
432
433 Session session = null;
434
435 try {
436 session = openSession();
437
438 Query q = session.createQuery(sql);
439
440 QueryPos qPos = QueryPos.getInstance(q);
441
442 qPos.add(companyId);
443
444 list = (List<Address>)QueryUtil.list(q, getDialect(), start, end);
445 }
446 catch (Exception e) {
447 throw processException(e);
448 }
449 finally {
450 if (list == null) {
451 list = new ArrayList<Address>();
452 }
453
454 cacheResult(list);
455
456 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_COMPANYID,
457 finderArgs, list);
458
459 closeSession(session);
460 }
461 }
462
463 return list;
464 }
465
466 public Address findByCompanyId_First(long companyId,
467 OrderByComparator orderByComparator)
468 throws NoSuchAddressException, SystemException {
469 List<Address> list = findByCompanyId(companyId, 0, 1, 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 NoSuchAddressException(msg.toString());
482 }
483 else {
484 return list.get(0);
485 }
486 }
487
488 public Address findByCompanyId_Last(long companyId,
489 OrderByComparator orderByComparator)
490 throws NoSuchAddressException, SystemException {
491 int count = countByCompanyId(companyId);
492
493 List<Address> list = findByCompanyId(companyId, count - 1, count,
494 orderByComparator);
495
496 if (list.isEmpty()) {
497 StringBundler msg = new StringBundler(4);
498
499 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
500
501 msg.append("companyId=");
502 msg.append(companyId);
503
504 msg.append(StringPool.CLOSE_CURLY_BRACE);
505
506 throw new NoSuchAddressException(msg.toString());
507 }
508 else {
509 return list.get(0);
510 }
511 }
512
513 public Address[] findByCompanyId_PrevAndNext(long addressId,
514 long companyId, OrderByComparator orderByComparator)
515 throws NoSuchAddressException, SystemException {
516 Address address = findByPrimaryKey(addressId);
517
518 Session session = null;
519
520 try {
521 session = openSession();
522
523 Address[] array = new AddressImpl[3];
524
525 array[0] = getByCompanyId_PrevAndNext(session, address, companyId,
526 orderByComparator, true);
527
528 array[1] = address;
529
530 array[2] = getByCompanyId_PrevAndNext(session, address, companyId,
531 orderByComparator, false);
532
533 return array;
534 }
535 catch (Exception e) {
536 throw processException(e);
537 }
538 finally {
539 closeSession(session);
540 }
541 }
542
543 protected Address getByCompanyId_PrevAndNext(Session session,
544 Address address, long companyId, OrderByComparator orderByComparator,
545 boolean previous) {
546 StringBundler query = null;
547
548 if (orderByComparator != null) {
549 query = new StringBundler(6 +
550 (orderByComparator.getOrderByFields().length * 6));
551 }
552 else {
553 query = new StringBundler(3);
554 }
555
556 query.append(_SQL_SELECT_ADDRESS_WHERE);
557
558 query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
559
560 if (orderByComparator != null) {
561 String[] orderByFields = orderByComparator.getOrderByFields();
562
563 if (orderByFields.length > 0) {
564 query.append(WHERE_AND);
565 }
566
567 for (int i = 0; i < orderByFields.length; i++) {
568 query.append(_ORDER_BY_ENTITY_ALIAS);
569 query.append(orderByFields[i]);
570
571 if ((i + 1) < orderByFields.length) {
572 if (orderByComparator.isAscending() ^ previous) {
573 query.append(WHERE_GREATER_THAN_HAS_NEXT);
574 }
575 else {
576 query.append(WHERE_LESSER_THAN_HAS_NEXT);
577 }
578 }
579 else {
580 if (orderByComparator.isAscending() ^ previous) {
581 query.append(WHERE_GREATER_THAN);
582 }
583 else {
584 query.append(WHERE_LESSER_THAN);
585 }
586 }
587 }
588
589 query.append(ORDER_BY_CLAUSE);
590
591 for (int i = 0; i < orderByFields.length; i++) {
592 query.append(_ORDER_BY_ENTITY_ALIAS);
593 query.append(orderByFields[i]);
594
595 if ((i + 1) < orderByFields.length) {
596 if (orderByComparator.isAscending() ^ previous) {
597 query.append(ORDER_BY_ASC_HAS_NEXT);
598 }
599 else {
600 query.append(ORDER_BY_DESC_HAS_NEXT);
601 }
602 }
603 else {
604 if (orderByComparator.isAscending() ^ previous) {
605 query.append(ORDER_BY_ASC);
606 }
607 else {
608 query.append(ORDER_BY_DESC);
609 }
610 }
611 }
612 }
613
614 else {
615 query.append(AddressModelImpl.ORDER_BY_JPQL);
616 }
617
618 String sql = query.toString();
619
620 Query q = session.createQuery(sql);
621
622 q.setFirstResult(0);
623 q.setMaxResults(2);
624
625 QueryPos qPos = QueryPos.getInstance(q);
626
627 qPos.add(companyId);
628
629 if (orderByComparator != null) {
630 Object[] values = orderByComparator.getOrderByValues(address);
631
632 for (Object value : values) {
633 qPos.add(value);
634 }
635 }
636
637 List<Address> list = q.list();
638
639 if (list.size() == 2) {
640 return list.get(1);
641 }
642 else {
643 return null;
644 }
645 }
646
647 public List<Address> findByUserId(long userId) throws SystemException {
648 return findByUserId(userId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
649 }
650
651 public List<Address> findByUserId(long userId, int start, int end)
652 throws SystemException {
653 return findByUserId(userId, start, end, null);
654 }
655
656 public List<Address> findByUserId(long userId, int start, int end,
657 OrderByComparator orderByComparator) throws SystemException {
658 Object[] finderArgs = new Object[] {
659 userId,
660
661 String.valueOf(start), String.valueOf(end),
662 String.valueOf(orderByComparator)
663 };
664
665 List<Address> list = (List<Address>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_USERID,
666 finderArgs, this);
667
668 if (list == null) {
669 StringBundler query = null;
670
671 if (orderByComparator != null) {
672 query = new StringBundler(3 +
673 (orderByComparator.getOrderByFields().length * 3));
674 }
675 else {
676 query = new StringBundler(3);
677 }
678
679 query.append(_SQL_SELECT_ADDRESS_WHERE);
680
681 query.append(_FINDER_COLUMN_USERID_USERID_2);
682
683 if (orderByComparator != null) {
684 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
685 orderByComparator);
686 }
687
688 else {
689 query.append(AddressModelImpl.ORDER_BY_JPQL);
690 }
691
692 String sql = query.toString();
693
694 Session session = null;
695
696 try {
697 session = openSession();
698
699 Query q = session.createQuery(sql);
700
701 QueryPos qPos = QueryPos.getInstance(q);
702
703 qPos.add(userId);
704
705 list = (List<Address>)QueryUtil.list(q, getDialect(), start, end);
706 }
707 catch (Exception e) {
708 throw processException(e);
709 }
710 finally {
711 if (list == null) {
712 list = new ArrayList<Address>();
713 }
714
715 cacheResult(list);
716
717 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_USERID,
718 finderArgs, list);
719
720 closeSession(session);
721 }
722 }
723
724 return list;
725 }
726
727 public Address findByUserId_First(long userId,
728 OrderByComparator orderByComparator)
729 throws NoSuchAddressException, SystemException {
730 List<Address> list = findByUserId(userId, 0, 1, orderByComparator);
731
732 if (list.isEmpty()) {
733 StringBundler msg = new StringBundler(4);
734
735 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
736
737 msg.append("userId=");
738 msg.append(userId);
739
740 msg.append(StringPool.CLOSE_CURLY_BRACE);
741
742 throw new NoSuchAddressException(msg.toString());
743 }
744 else {
745 return list.get(0);
746 }
747 }
748
749 public Address findByUserId_Last(long userId,
750 OrderByComparator orderByComparator)
751 throws NoSuchAddressException, SystemException {
752 int count = countByUserId(userId);
753
754 List<Address> list = findByUserId(userId, count - 1, count,
755 orderByComparator);
756
757 if (list.isEmpty()) {
758 StringBundler msg = new StringBundler(4);
759
760 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
761
762 msg.append("userId=");
763 msg.append(userId);
764
765 msg.append(StringPool.CLOSE_CURLY_BRACE);
766
767 throw new NoSuchAddressException(msg.toString());
768 }
769 else {
770 return list.get(0);
771 }
772 }
773
774 public Address[] findByUserId_PrevAndNext(long addressId, long userId,
775 OrderByComparator orderByComparator)
776 throws NoSuchAddressException, SystemException {
777 Address address = findByPrimaryKey(addressId);
778
779 Session session = null;
780
781 try {
782 session = openSession();
783
784 Address[] array = new AddressImpl[3];
785
786 array[0] = getByUserId_PrevAndNext(session, address, userId,
787 orderByComparator, true);
788
789 array[1] = address;
790
791 array[2] = getByUserId_PrevAndNext(session, address, userId,
792 orderByComparator, false);
793
794 return array;
795 }
796 catch (Exception e) {
797 throw processException(e);
798 }
799 finally {
800 closeSession(session);
801 }
802 }
803
804 protected Address getByUserId_PrevAndNext(Session session, Address address,
805 long userId, 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_ADDRESS_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(AddressModelImpl.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(address);
891
892 for (Object value : values) {
893 qPos.add(value);
894 }
895 }
896
897 List<Address> 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<Address> 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<Address> findByC_C(long companyId, long classNameId, int start,
914 int end) throws SystemException {
915 return findByC_C(companyId, classNameId, start, end, null);
916 }
917
918 public List<Address> findByC_C(long companyId, long classNameId, int start,
919 int end, OrderByComparator orderByComparator) throws SystemException {
920 Object[] finderArgs = new Object[] {
921 companyId, classNameId,
922
923 String.valueOf(start), String.valueOf(end),
924 String.valueOf(orderByComparator)
925 };
926
927 List<Address> list = (List<Address>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_C_C,
928 finderArgs, this);
929
930 if (list == null) {
931 StringBundler query = null;
932
933 if (orderByComparator != null) {
934 query = new StringBundler(4 +
935 (orderByComparator.getOrderByFields().length * 3));
936 }
937 else {
938 query = new StringBundler(4);
939 }
940
941 query.append(_SQL_SELECT_ADDRESS_WHERE);
942
943 query.append(_FINDER_COLUMN_C_C_COMPANYID_2);
944
945 query.append(_FINDER_COLUMN_C_C_CLASSNAMEID_2);
946
947 if (orderByComparator != null) {
948 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
949 orderByComparator);
950 }
951
952 else {
953 query.append(AddressModelImpl.ORDER_BY_JPQL);
954 }
955
956 String sql = query.toString();
957
958 Session session = null;
959
960 try {
961 session = openSession();
962
963 Query q = session.createQuery(sql);
964
965 QueryPos qPos = QueryPos.getInstance(q);
966
967 qPos.add(companyId);
968
969 qPos.add(classNameId);
970
971 list = (List<Address>)QueryUtil.list(q, getDialect(), start, end);
972 }
973 catch (Exception e) {
974 throw processException(e);
975 }
976 finally {
977 if (list == null) {
978 list = new ArrayList<Address>();
979 }
980
981 cacheResult(list);
982
983 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_C_C, finderArgs,
984 list);
985
986 closeSession(session);
987 }
988 }
989
990 return list;
991 }
992
993 public Address findByC_C_First(long companyId, long classNameId,
994 OrderByComparator orderByComparator)
995 throws NoSuchAddressException, SystemException {
996 List<Address> list = findByC_C(companyId, classNameId, 0, 1,
997 orderByComparator);
998
999 if (list.isEmpty()) {
1000 StringBundler msg = new StringBundler(6);
1001
1002 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1003
1004 msg.append("companyId=");
1005 msg.append(companyId);
1006
1007 msg.append(", classNameId=");
1008 msg.append(classNameId);
1009
1010 msg.append(StringPool.CLOSE_CURLY_BRACE);
1011
1012 throw new NoSuchAddressException(msg.toString());
1013 }
1014 else {
1015 return list.get(0);
1016 }
1017 }
1018
1019 public Address findByC_C_Last(long companyId, long classNameId,
1020 OrderByComparator orderByComparator)
1021 throws NoSuchAddressException, SystemException {
1022 int count = countByC_C(companyId, classNameId);
1023
1024 List<Address> list = findByC_C(companyId, classNameId, count - 1,
1025 count, orderByComparator);
1026
1027 if (list.isEmpty()) {
1028 StringBundler msg = new StringBundler(6);
1029
1030 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1031
1032 msg.append("companyId=");
1033 msg.append(companyId);
1034
1035 msg.append(", classNameId=");
1036 msg.append(classNameId);
1037
1038 msg.append(StringPool.CLOSE_CURLY_BRACE);
1039
1040 throw new NoSuchAddressException(msg.toString());
1041 }
1042 else {
1043 return list.get(0);
1044 }
1045 }
1046
1047 public Address[] findByC_C_PrevAndNext(long addressId, long companyId,
1048 long classNameId, OrderByComparator orderByComparator)
1049 throws NoSuchAddressException, SystemException {
1050 Address address = findByPrimaryKey(addressId);
1051
1052 Session session = null;
1053
1054 try {
1055 session = openSession();
1056
1057 Address[] array = new AddressImpl[3];
1058
1059 array[0] = getByC_C_PrevAndNext(session, address, companyId,
1060 classNameId, orderByComparator, true);
1061
1062 array[1] = address;
1063
1064 array[2] = getByC_C_PrevAndNext(session, address, companyId,
1065 classNameId, orderByComparator, false);
1066
1067 return array;
1068 }
1069 catch (Exception e) {
1070 throw processException(e);
1071 }
1072 finally {
1073 closeSession(session);
1074 }
1075 }
1076
1077 protected Address getByC_C_PrevAndNext(Session session, Address address,
1078 long companyId, long classNameId, OrderByComparator orderByComparator,
1079 boolean previous) {
1080 StringBundler query = null;
1081
1082 if (orderByComparator != null) {
1083 query = new StringBundler(6 +
1084 (orderByComparator.getOrderByFields().length * 6));
1085 }
1086 else {
1087 query = new StringBundler(3);
1088 }
1089
1090 query.append(_SQL_SELECT_ADDRESS_WHERE);
1091
1092 query.append(_FINDER_COLUMN_C_C_COMPANYID_2);
1093
1094 query.append(_FINDER_COLUMN_C_C_CLASSNAMEID_2);
1095
1096 if (orderByComparator != null) {
1097 String[] orderByFields = orderByComparator.getOrderByFields();
1098
1099 if (orderByFields.length > 0) {
1100 query.append(WHERE_AND);
1101 }
1102
1103 for (int i = 0; i < orderByFields.length; i++) {
1104 query.append(_ORDER_BY_ENTITY_ALIAS);
1105 query.append(orderByFields[i]);
1106
1107 if ((i + 1) < orderByFields.length) {
1108 if (orderByComparator.isAscending() ^ previous) {
1109 query.append(WHERE_GREATER_THAN_HAS_NEXT);
1110 }
1111 else {
1112 query.append(WHERE_LESSER_THAN_HAS_NEXT);
1113 }
1114 }
1115 else {
1116 if (orderByComparator.isAscending() ^ previous) {
1117 query.append(WHERE_GREATER_THAN);
1118 }
1119 else {
1120 query.append(WHERE_LESSER_THAN);
1121 }
1122 }
1123 }
1124
1125 query.append(ORDER_BY_CLAUSE);
1126
1127 for (int i = 0; i < orderByFields.length; i++) {
1128 query.append(_ORDER_BY_ENTITY_ALIAS);
1129 query.append(orderByFields[i]);
1130
1131 if ((i + 1) < orderByFields.length) {
1132 if (orderByComparator.isAscending() ^ previous) {
1133 query.append(ORDER_BY_ASC_HAS_NEXT);
1134 }
1135 else {
1136 query.append(ORDER_BY_DESC_HAS_NEXT);
1137 }
1138 }
1139 else {
1140 if (orderByComparator.isAscending() ^ previous) {
1141 query.append(ORDER_BY_ASC);
1142 }
1143 else {
1144 query.append(ORDER_BY_DESC);
1145 }
1146 }
1147 }
1148 }
1149
1150 else {
1151 query.append(AddressModelImpl.ORDER_BY_JPQL);
1152 }
1153
1154 String sql = query.toString();
1155
1156 Query q = session.createQuery(sql);
1157
1158 q.setFirstResult(0);
1159 q.setMaxResults(2);
1160
1161 QueryPos qPos = QueryPos.getInstance(q);
1162
1163 qPos.add(companyId);
1164
1165 qPos.add(classNameId);
1166
1167 if (orderByComparator != null) {
1168 Object[] values = orderByComparator.getOrderByValues(address);
1169
1170 for (Object value : values) {
1171 qPos.add(value);
1172 }
1173 }
1174
1175 List<Address> list = q.list();
1176
1177 if (list.size() == 2) {
1178 return list.get(1);
1179 }
1180 else {
1181 return null;
1182 }
1183 }
1184
1185 public List<Address> findByC_C_C(long companyId, long classNameId,
1186 long classPK) throws SystemException {
1187 return findByC_C_C(companyId, classNameId, classPK, QueryUtil.ALL_POS,
1188 QueryUtil.ALL_POS, null);
1189 }
1190
1191 public List<Address> findByC_C_C(long companyId, long classNameId,
1192 long classPK, int start, int end) throws SystemException {
1193 return findByC_C_C(companyId, classNameId, classPK, start, end, null);
1194 }
1195
1196 public List<Address> findByC_C_C(long companyId, long classNameId,
1197 long classPK, int start, int end, OrderByComparator orderByComparator)
1198 throws SystemException {
1199 Object[] finderArgs = new Object[] {
1200 companyId, classNameId, classPK,
1201
1202 String.valueOf(start), String.valueOf(end),
1203 String.valueOf(orderByComparator)
1204 };
1205
1206 List<Address> list = (List<Address>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_C_C_C,
1207 finderArgs, this);
1208
1209 if (list == null) {
1210 StringBundler query = null;
1211
1212 if (orderByComparator != null) {
1213 query = new StringBundler(5 +
1214 (orderByComparator.getOrderByFields().length * 3));
1215 }
1216 else {
1217 query = new StringBundler(5);
1218 }
1219
1220 query.append(_SQL_SELECT_ADDRESS_WHERE);
1221
1222 query.append(_FINDER_COLUMN_C_C_C_COMPANYID_2);
1223
1224 query.append(_FINDER_COLUMN_C_C_C_CLASSNAMEID_2);
1225
1226 query.append(_FINDER_COLUMN_C_C_C_CLASSPK_2);
1227
1228 if (orderByComparator != null) {
1229 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1230 orderByComparator);
1231 }
1232
1233 else {
1234 query.append(AddressModelImpl.ORDER_BY_JPQL);
1235 }
1236
1237 String sql = query.toString();
1238
1239 Session session = null;
1240
1241 try {
1242 session = openSession();
1243
1244 Query q = session.createQuery(sql);
1245
1246 QueryPos qPos = QueryPos.getInstance(q);
1247
1248 qPos.add(companyId);
1249
1250 qPos.add(classNameId);
1251
1252 qPos.add(classPK);
1253
1254 list = (List<Address>)QueryUtil.list(q, getDialect(), start, end);
1255 }
1256 catch (Exception e) {
1257 throw processException(e);
1258 }
1259 finally {
1260 if (list == null) {
1261 list = new ArrayList<Address>();
1262 }
1263
1264 cacheResult(list);
1265
1266 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_C_C_C,
1267 finderArgs, list);
1268
1269 closeSession(session);
1270 }
1271 }
1272
1273 return list;
1274 }
1275
1276 public Address findByC_C_C_First(long companyId, long classNameId,
1277 long classPK, OrderByComparator orderByComparator)
1278 throws NoSuchAddressException, SystemException {
1279 List<Address> list = findByC_C_C(companyId, classNameId, classPK, 0, 1,
1280 orderByComparator);
1281
1282 if (list.isEmpty()) {
1283 StringBundler msg = new StringBundler(8);
1284
1285 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1286
1287 msg.append("companyId=");
1288 msg.append(companyId);
1289
1290 msg.append(", classNameId=");
1291 msg.append(classNameId);
1292
1293 msg.append(", classPK=");
1294 msg.append(classPK);
1295
1296 msg.append(StringPool.CLOSE_CURLY_BRACE);
1297
1298 throw new NoSuchAddressException(msg.toString());
1299 }
1300 else {
1301 return list.get(0);
1302 }
1303 }
1304
1305 public Address findByC_C_C_Last(long companyId, long classNameId,
1306 long classPK, OrderByComparator orderByComparator)
1307 throws NoSuchAddressException, SystemException {
1308 int count = countByC_C_C(companyId, classNameId, classPK);
1309
1310 List<Address> list = findByC_C_C(companyId, classNameId, classPK,
1311 count - 1, count, orderByComparator);
1312
1313 if (list.isEmpty()) {
1314 StringBundler msg = new StringBundler(8);
1315
1316 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1317
1318 msg.append("companyId=");
1319 msg.append(companyId);
1320
1321 msg.append(", classNameId=");
1322 msg.append(classNameId);
1323
1324 msg.append(", classPK=");
1325 msg.append(classPK);
1326
1327 msg.append(StringPool.CLOSE_CURLY_BRACE);
1328
1329 throw new NoSuchAddressException(msg.toString());
1330 }
1331 else {
1332 return list.get(0);
1333 }
1334 }
1335
1336 public Address[] findByC_C_C_PrevAndNext(long addressId, long companyId,
1337 long classNameId, long classPK, OrderByComparator orderByComparator)
1338 throws NoSuchAddressException, SystemException {
1339 Address address = findByPrimaryKey(addressId);
1340
1341 Session session = null;
1342
1343 try {
1344 session = openSession();
1345
1346 Address[] array = new AddressImpl[3];
1347
1348 array[0] = getByC_C_C_PrevAndNext(session, address, companyId,
1349 classNameId, classPK, orderByComparator, true);
1350
1351 array[1] = address;
1352
1353 array[2] = getByC_C_C_PrevAndNext(session, address, companyId,
1354 classNameId, classPK, orderByComparator, false);
1355
1356 return array;
1357 }
1358 catch (Exception e) {
1359 throw processException(e);
1360 }
1361 finally {
1362 closeSession(session);
1363 }
1364 }
1365
1366 protected Address getByC_C_C_PrevAndNext(Session session, Address address,
1367 long companyId, long classNameId, long classPK,
1368 OrderByComparator orderByComparator, boolean previous) {
1369 StringBundler query = null;
1370
1371 if (orderByComparator != null) {
1372 query = new StringBundler(6 +
1373 (orderByComparator.getOrderByFields().length * 6));
1374 }
1375 else {
1376 query = new StringBundler(3);
1377 }
1378
1379 query.append(_SQL_SELECT_ADDRESS_WHERE);
1380
1381 query.append(_FINDER_COLUMN_C_C_C_COMPANYID_2);
1382
1383 query.append(_FINDER_COLUMN_C_C_C_CLASSNAMEID_2);
1384
1385 query.append(_FINDER_COLUMN_C_C_C_CLASSPK_2);
1386
1387 if (orderByComparator != null) {
1388 String[] orderByFields = orderByComparator.getOrderByFields();
1389
1390 if (orderByFields.length > 0) {
1391 query.append(WHERE_AND);
1392 }
1393
1394 for (int i = 0; i < orderByFields.length; i++) {
1395 query.append(_ORDER_BY_ENTITY_ALIAS);
1396 query.append(orderByFields[i]);
1397
1398 if ((i + 1) < orderByFields.length) {
1399 if (orderByComparator.isAscending() ^ previous) {
1400 query.append(WHERE_GREATER_THAN_HAS_NEXT);
1401 }
1402 else {
1403 query.append(WHERE_LESSER_THAN_HAS_NEXT);
1404 }
1405 }
1406 else {
1407 if (orderByComparator.isAscending() ^ previous) {
1408 query.append(WHERE_GREATER_THAN);
1409 }
1410 else {
1411 query.append(WHERE_LESSER_THAN);
1412 }
1413 }
1414 }
1415
1416 query.append(ORDER_BY_CLAUSE);
1417
1418 for (int i = 0; i < orderByFields.length; i++) {
1419 query.append(_ORDER_BY_ENTITY_ALIAS);
1420 query.append(orderByFields[i]);
1421
1422 if ((i + 1) < orderByFields.length) {
1423 if (orderByComparator.isAscending() ^ previous) {
1424 query.append(ORDER_BY_ASC_HAS_NEXT);
1425 }
1426 else {
1427 query.append(ORDER_BY_DESC_HAS_NEXT);
1428 }
1429 }
1430 else {
1431 if (orderByComparator.isAscending() ^ previous) {
1432 query.append(ORDER_BY_ASC);
1433 }
1434 else {
1435 query.append(ORDER_BY_DESC);
1436 }
1437 }
1438 }
1439 }
1440
1441 else {
1442 query.append(AddressModelImpl.ORDER_BY_JPQL);
1443 }
1444
1445 String sql = query.toString();
1446
1447 Query q = session.createQuery(sql);
1448
1449 q.setFirstResult(0);
1450 q.setMaxResults(2);
1451
1452 QueryPos qPos = QueryPos.getInstance(q);
1453
1454 qPos.add(companyId);
1455
1456 qPos.add(classNameId);
1457
1458 qPos.add(classPK);
1459
1460 if (orderByComparator != null) {
1461 Object[] values = orderByComparator.getOrderByValues(address);
1462
1463 for (Object value : values) {
1464 qPos.add(value);
1465 }
1466 }
1467
1468 List<Address> list = q.list();
1469
1470 if (list.size() == 2) {
1471 return list.get(1);
1472 }
1473 else {
1474 return null;
1475 }
1476 }
1477
1478 public List<Address> findByC_C_C_M(long companyId, long classNameId,
1479 long classPK, boolean mailing) throws SystemException {
1480 return findByC_C_C_M(companyId, classNameId, classPK, mailing,
1481 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1482 }
1483
1484 public List<Address> findByC_C_C_M(long companyId, long classNameId,
1485 long classPK, boolean mailing, int start, int end)
1486 throws SystemException {
1487 return findByC_C_C_M(companyId, classNameId, classPK, mailing, start,
1488 end, null);
1489 }
1490
1491 public List<Address> findByC_C_C_M(long companyId, long classNameId,
1492 long classPK, boolean mailing, int start, int end,
1493 OrderByComparator orderByComparator) throws SystemException {
1494 Object[] finderArgs = new Object[] {
1495 companyId, classNameId, classPK, mailing,
1496
1497 String.valueOf(start), String.valueOf(end),
1498 String.valueOf(orderByComparator)
1499 };
1500
1501 List<Address> list = (List<Address>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_C_C_C_M,
1502 finderArgs, this);
1503
1504 if (list == null) {
1505 StringBundler query = null;
1506
1507 if (orderByComparator != null) {
1508 query = new StringBundler(6 +
1509 (orderByComparator.getOrderByFields().length * 3));
1510 }
1511 else {
1512 query = new StringBundler(6);
1513 }
1514
1515 query.append(_SQL_SELECT_ADDRESS_WHERE);
1516
1517 query.append(_FINDER_COLUMN_C_C_C_M_COMPANYID_2);
1518
1519 query.append(_FINDER_COLUMN_C_C_C_M_CLASSNAMEID_2);
1520
1521 query.append(_FINDER_COLUMN_C_C_C_M_CLASSPK_2);
1522
1523 query.append(_FINDER_COLUMN_C_C_C_M_MAILING_2);
1524
1525 if (orderByComparator != null) {
1526 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1527 orderByComparator);
1528 }
1529
1530 else {
1531 query.append(AddressModelImpl.ORDER_BY_JPQL);
1532 }
1533
1534 String sql = query.toString();
1535
1536 Session session = null;
1537
1538 try {
1539 session = openSession();
1540
1541 Query q = session.createQuery(sql);
1542
1543 QueryPos qPos = QueryPos.getInstance(q);
1544
1545 qPos.add(companyId);
1546
1547 qPos.add(classNameId);
1548
1549 qPos.add(classPK);
1550
1551 qPos.add(mailing);
1552
1553 list = (List<Address>)QueryUtil.list(q, getDialect(), start, end);
1554 }
1555 catch (Exception e) {
1556 throw processException(e);
1557 }
1558 finally {
1559 if (list == null) {
1560 list = new ArrayList<Address>();
1561 }
1562
1563 cacheResult(list);
1564
1565 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_C_C_C_M,
1566 finderArgs, list);
1567
1568 closeSession(session);
1569 }
1570 }
1571
1572 return list;
1573 }
1574
1575 public Address findByC_C_C_M_First(long companyId, long classNameId,
1576 long classPK, boolean mailing, OrderByComparator orderByComparator)
1577 throws NoSuchAddressException, SystemException {
1578 List<Address> list = findByC_C_C_M(companyId, classNameId, classPK,
1579 mailing, 0, 1, orderByComparator);
1580
1581 if (list.isEmpty()) {
1582 StringBundler msg = new StringBundler(10);
1583
1584 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1585
1586 msg.append("companyId=");
1587 msg.append(companyId);
1588
1589 msg.append(", classNameId=");
1590 msg.append(classNameId);
1591
1592 msg.append(", classPK=");
1593 msg.append(classPK);
1594
1595 msg.append(", mailing=");
1596 msg.append(mailing);
1597
1598 msg.append(StringPool.CLOSE_CURLY_BRACE);
1599
1600 throw new NoSuchAddressException(msg.toString());
1601 }
1602 else {
1603 return list.get(0);
1604 }
1605 }
1606
1607 public Address findByC_C_C_M_Last(long companyId, long classNameId,
1608 long classPK, boolean mailing, OrderByComparator orderByComparator)
1609 throws NoSuchAddressException, SystemException {
1610 int count = countByC_C_C_M(companyId, classNameId, classPK, mailing);
1611
1612 List<Address> list = findByC_C_C_M(companyId, classNameId, classPK,
1613 mailing, count - 1, count, orderByComparator);
1614
1615 if (list.isEmpty()) {
1616 StringBundler msg = new StringBundler(10);
1617
1618 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1619
1620 msg.append("companyId=");
1621 msg.append(companyId);
1622
1623 msg.append(", classNameId=");
1624 msg.append(classNameId);
1625
1626 msg.append(", classPK=");
1627 msg.append(classPK);
1628
1629 msg.append(", mailing=");
1630 msg.append(mailing);
1631
1632 msg.append(StringPool.CLOSE_CURLY_BRACE);
1633
1634 throw new NoSuchAddressException(msg.toString());
1635 }
1636 else {
1637 return list.get(0);
1638 }
1639 }
1640
1641 public Address[] findByC_C_C_M_PrevAndNext(long addressId, long companyId,
1642 long classNameId, long classPK, boolean mailing,
1643 OrderByComparator orderByComparator)
1644 throws NoSuchAddressException, SystemException {
1645 Address address = findByPrimaryKey(addressId);
1646
1647 Session session = null;
1648
1649 try {
1650 session = openSession();
1651
1652 Address[] array = new AddressImpl[3];
1653
1654 array[0] = getByC_C_C_M_PrevAndNext(session, address, companyId,
1655 classNameId, classPK, mailing, orderByComparator, true);
1656
1657 array[1] = address;
1658
1659 array[2] = getByC_C_C_M_PrevAndNext(session, address, companyId,
1660 classNameId, classPK, mailing, orderByComparator, false);
1661
1662 return array;
1663 }
1664 catch (Exception e) {
1665 throw processException(e);
1666 }
1667 finally {
1668 closeSession(session);
1669 }
1670 }
1671
1672 protected Address getByC_C_C_M_PrevAndNext(Session session,
1673 Address address, long companyId, long classNameId, long classPK,
1674 boolean mailing, OrderByComparator orderByComparator, boolean previous) {
1675 StringBundler query = null;
1676
1677 if (orderByComparator != null) {
1678 query = new StringBundler(6 +
1679 (orderByComparator.getOrderByFields().length * 6));
1680 }
1681 else {
1682 query = new StringBundler(3);
1683 }
1684
1685 query.append(_SQL_SELECT_ADDRESS_WHERE);
1686
1687 query.append(_FINDER_COLUMN_C_C_C_M_COMPANYID_2);
1688
1689 query.append(_FINDER_COLUMN_C_C_C_M_CLASSNAMEID_2);
1690
1691 query.append(_FINDER_COLUMN_C_C_C_M_CLASSPK_2);
1692
1693 query.append(_FINDER_COLUMN_C_C_C_M_MAILING_2);
1694
1695 if (orderByComparator != null) {
1696 String[] orderByFields = orderByComparator.getOrderByFields();
1697
1698 if (orderByFields.length > 0) {
1699 query.append(WHERE_AND);
1700 }
1701
1702 for (int i = 0; i < orderByFields.length; i++) {
1703 query.append(_ORDER_BY_ENTITY_ALIAS);
1704 query.append(orderByFields[i]);
1705
1706 if ((i + 1) < orderByFields.length) {
1707 if (orderByComparator.isAscending() ^ previous) {
1708 query.append(WHERE_GREATER_THAN_HAS_NEXT);
1709 }
1710 else {
1711 query.append(WHERE_LESSER_THAN_HAS_NEXT);
1712 }
1713 }
1714 else {
1715 if (orderByComparator.isAscending() ^ previous) {
1716 query.append(WHERE_GREATER_THAN);
1717 }
1718 else {
1719 query.append(WHERE_LESSER_THAN);
1720 }
1721 }
1722 }
1723
1724 query.append(ORDER_BY_CLAUSE);
1725
1726 for (int i = 0; i < orderByFields.length; i++) {
1727 query.append(_ORDER_BY_ENTITY_ALIAS);
1728 query.append(orderByFields[i]);
1729
1730 if ((i + 1) < orderByFields.length) {
1731 if (orderByComparator.isAscending() ^ previous) {
1732 query.append(ORDER_BY_ASC_HAS_NEXT);
1733 }
1734 else {
1735 query.append(ORDER_BY_DESC_HAS_NEXT);
1736 }
1737 }
1738 else {
1739 if (orderByComparator.isAscending() ^ previous) {
1740 query.append(ORDER_BY_ASC);
1741 }
1742 else {
1743 query.append(ORDER_BY_DESC);
1744 }
1745 }
1746 }
1747 }
1748
1749 else {
1750 query.append(AddressModelImpl.ORDER_BY_JPQL);
1751 }
1752
1753 String sql = query.toString();
1754
1755 Query q = session.createQuery(sql);
1756
1757 q.setFirstResult(0);
1758 q.setMaxResults(2);
1759
1760 QueryPos qPos = QueryPos.getInstance(q);
1761
1762 qPos.add(companyId);
1763
1764 qPos.add(classNameId);
1765
1766 qPos.add(classPK);
1767
1768 qPos.add(mailing);
1769
1770 if (orderByComparator != null) {
1771 Object[] values = orderByComparator.getOrderByValues(address);
1772
1773 for (Object value : values) {
1774 qPos.add(value);
1775 }
1776 }
1777
1778 List<Address> list = q.list();
1779
1780 if (list.size() == 2) {
1781 return list.get(1);
1782 }
1783 else {
1784 return null;
1785 }
1786 }
1787
1788 public List<Address> findByC_C_C_P(long companyId, long classNameId,
1789 long classPK, boolean primary) throws SystemException {
1790 return findByC_C_C_P(companyId, classNameId, classPK, primary,
1791 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1792 }
1793
1794 public List<Address> findByC_C_C_P(long companyId, long classNameId,
1795 long classPK, boolean primary, int start, int end)
1796 throws SystemException {
1797 return findByC_C_C_P(companyId, classNameId, classPK, primary, start,
1798 end, null);
1799 }
1800
1801 public List<Address> findByC_C_C_P(long companyId, long classNameId,
1802 long classPK, boolean primary, int start, int end,
1803 OrderByComparator orderByComparator) throws SystemException {
1804 Object[] finderArgs = new Object[] {
1805 companyId, classNameId, classPK, primary,
1806
1807 String.valueOf(start), String.valueOf(end),
1808 String.valueOf(orderByComparator)
1809 };
1810
1811 List<Address> list = (List<Address>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_C_C_C_P,
1812 finderArgs, this);
1813
1814 if (list == null) {
1815 StringBundler query = null;
1816
1817 if (orderByComparator != null) {
1818 query = new StringBundler(6 +
1819 (orderByComparator.getOrderByFields().length * 3));
1820 }
1821 else {
1822 query = new StringBundler(6);
1823 }
1824
1825 query.append(_SQL_SELECT_ADDRESS_WHERE);
1826
1827 query.append(_FINDER_COLUMN_C_C_C_P_COMPANYID_2);
1828
1829 query.append(_FINDER_COLUMN_C_C_C_P_CLASSNAMEID_2);
1830
1831 query.append(_FINDER_COLUMN_C_C_C_P_CLASSPK_2);
1832
1833 query.append(_FINDER_COLUMN_C_C_C_P_PRIMARY_2);
1834
1835 if (orderByComparator != null) {
1836 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1837 orderByComparator);
1838 }
1839
1840 else {
1841 query.append(AddressModelImpl.ORDER_BY_JPQL);
1842 }
1843
1844 String sql = query.toString();
1845
1846 Session session = null;
1847
1848 try {
1849 session = openSession();
1850
1851 Query q = session.createQuery(sql);
1852
1853 QueryPos qPos = QueryPos.getInstance(q);
1854
1855 qPos.add(companyId);
1856
1857 qPos.add(classNameId);
1858
1859 qPos.add(classPK);
1860
1861 qPos.add(primary);
1862
1863 list = (List<Address>)QueryUtil.list(q, getDialect(), start, end);
1864 }
1865 catch (Exception e) {
1866 throw processException(e);
1867 }
1868 finally {
1869 if (list == null) {
1870 list = new ArrayList<Address>();
1871 }
1872
1873 cacheResult(list);
1874
1875 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_C_C_C_P,
1876 finderArgs, list);
1877
1878 closeSession(session);
1879 }
1880 }
1881
1882 return list;
1883 }
1884
1885 public Address findByC_C_C_P_First(long companyId, long classNameId,
1886 long classPK, boolean primary, OrderByComparator orderByComparator)
1887 throws NoSuchAddressException, SystemException {
1888 List<Address> list = findByC_C_C_P(companyId, classNameId, classPK,
1889 primary, 0, 1, orderByComparator);
1890
1891 if (list.isEmpty()) {
1892 StringBundler msg = new StringBundler(10);
1893
1894 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1895
1896 msg.append("companyId=");
1897 msg.append(companyId);
1898
1899 msg.append(", classNameId=");
1900 msg.append(classNameId);
1901
1902 msg.append(", classPK=");
1903 msg.append(classPK);
1904
1905 msg.append(", primary=");
1906 msg.append(primary);
1907
1908 msg.append(StringPool.CLOSE_CURLY_BRACE);
1909
1910 throw new NoSuchAddressException(msg.toString());
1911 }
1912 else {
1913 return list.get(0);
1914 }
1915 }
1916
1917 public Address findByC_C_C_P_Last(long companyId, long classNameId,
1918 long classPK, boolean primary, OrderByComparator orderByComparator)
1919 throws NoSuchAddressException, SystemException {
1920 int count = countByC_C_C_P(companyId, classNameId, classPK, primary);
1921
1922 List<Address> list = findByC_C_C_P(companyId, classNameId, classPK,
1923 primary, count - 1, count, orderByComparator);
1924
1925 if (list.isEmpty()) {
1926 StringBundler msg = new StringBundler(10);
1927
1928 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1929
1930 msg.append("companyId=");
1931 msg.append(companyId);
1932
1933 msg.append(", classNameId=");
1934 msg.append(classNameId);
1935
1936 msg.append(", classPK=");
1937 msg.append(classPK);
1938
1939 msg.append(", primary=");
1940 msg.append(primary);
1941
1942 msg.append(StringPool.CLOSE_CURLY_BRACE);
1943
1944 throw new NoSuchAddressException(msg.toString());
1945 }
1946 else {
1947 return list.get(0);
1948 }
1949 }
1950
1951 public Address[] findByC_C_C_P_PrevAndNext(long addressId, long companyId,
1952 long classNameId, long classPK, boolean primary,
1953 OrderByComparator orderByComparator)
1954 throws NoSuchAddressException, SystemException {
1955 Address address = findByPrimaryKey(addressId);
1956
1957 Session session = null;
1958
1959 try {
1960 session = openSession();
1961
1962 Address[] array = new AddressImpl[3];
1963
1964 array[0] = getByC_C_C_P_PrevAndNext(session, address, companyId,
1965 classNameId, classPK, primary, orderByComparator, true);
1966
1967 array[1] = address;
1968
1969 array[2] = getByC_C_C_P_PrevAndNext(session, address, companyId,
1970 classNameId, classPK, primary, orderByComparator, false);
1971
1972 return array;
1973 }
1974 catch (Exception e) {
1975 throw processException(e);
1976 }
1977 finally {
1978 closeSession(session);
1979 }
1980 }
1981
1982 protected Address getByC_C_C_P_PrevAndNext(Session session,
1983 Address address, long companyId, long classNameId, long classPK,
1984 boolean primary, OrderByComparator orderByComparator, boolean previous) {
1985 StringBundler query = null;
1986
1987 if (orderByComparator != null) {
1988 query = new StringBundler(6 +
1989 (orderByComparator.getOrderByFields().length * 6));
1990 }
1991 else {
1992 query = new StringBundler(3);
1993 }
1994
1995 query.append(_SQL_SELECT_ADDRESS_WHERE);
1996
1997 query.append(_FINDER_COLUMN_C_C_C_P_COMPANYID_2);
1998
1999 query.append(_FINDER_COLUMN_C_C_C_P_CLASSNAMEID_2);
2000
2001 query.append(_FINDER_COLUMN_C_C_C_P_CLASSPK_2);
2002
2003 query.append(_FINDER_COLUMN_C_C_C_P_PRIMARY_2);
2004
2005 if (orderByComparator != null) {
2006 String[] orderByFields = orderByComparator.getOrderByFields();
2007
2008 if (orderByFields.length > 0) {
2009 query.append(WHERE_AND);
2010 }
2011
2012 for (int i = 0; i < orderByFields.length; i++) {
2013 query.append(_ORDER_BY_ENTITY_ALIAS);
2014 query.append(orderByFields[i]);
2015
2016 if ((i + 1) < orderByFields.length) {
2017 if (orderByComparator.isAscending() ^ previous) {
2018 query.append(WHERE_GREATER_THAN_HAS_NEXT);
2019 }
2020 else {
2021 query.append(WHERE_LESSER_THAN_HAS_NEXT);
2022 }
2023 }
2024 else {
2025 if (orderByComparator.isAscending() ^ previous) {
2026 query.append(WHERE_GREATER_THAN);
2027 }
2028 else {
2029 query.append(WHERE_LESSER_THAN);
2030 }
2031 }
2032 }
2033
2034 query.append(ORDER_BY_CLAUSE);
2035
2036 for (int i = 0; i < orderByFields.length; i++) {
2037 query.append(_ORDER_BY_ENTITY_ALIAS);
2038 query.append(orderByFields[i]);
2039
2040 if ((i + 1) < orderByFields.length) {
2041 if (orderByComparator.isAscending() ^ previous) {
2042 query.append(ORDER_BY_ASC_HAS_NEXT);
2043 }
2044 else {
2045 query.append(ORDER_BY_DESC_HAS_NEXT);
2046 }
2047 }
2048 else {
2049 if (orderByComparator.isAscending() ^ previous) {
2050 query.append(ORDER_BY_ASC);
2051 }
2052 else {
2053 query.append(ORDER_BY_DESC);
2054 }
2055 }
2056 }
2057 }
2058
2059 else {
2060 query.append(AddressModelImpl.ORDER_BY_JPQL);
2061 }
2062
2063 String sql = query.toString();
2064
2065 Query q = session.createQuery(sql);
2066
2067 q.setFirstResult(0);
2068 q.setMaxResults(2);
2069
2070 QueryPos qPos = QueryPos.getInstance(q);
2071
2072 qPos.add(companyId);
2073
2074 qPos.add(classNameId);
2075
2076 qPos.add(classPK);
2077
2078 qPos.add(primary);
2079
2080 if (orderByComparator != null) {
2081 Object[] values = orderByComparator.getOrderByValues(address);
2082
2083 for (Object value : values) {
2084 qPos.add(value);
2085 }
2086 }
2087
2088 List<Address> list = q.list();
2089
2090 if (list.size() == 2) {
2091 return list.get(1);
2092 }
2093 else {
2094 return null;
2095 }
2096 }
2097
2098 public List<Address> findAll() throws SystemException {
2099 return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
2100 }
2101
2102 public List<Address> findAll(int start, int end) throws SystemException {
2103 return findAll(start, end, null);
2104 }
2105
2106 public List<Address> findAll(int start, int end,
2107 OrderByComparator orderByComparator) throws SystemException {
2108 Object[] finderArgs = new Object[] {
2109 String.valueOf(start), String.valueOf(end),
2110 String.valueOf(orderByComparator)
2111 };
2112
2113 List<Address> list = (List<Address>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
2114 finderArgs, this);
2115
2116 if (list == null) {
2117 StringBundler query = null;
2118 String sql = null;
2119
2120 if (orderByComparator != null) {
2121 query = new StringBundler(2 +
2122 (orderByComparator.getOrderByFields().length * 3));
2123
2124 query.append(_SQL_SELECT_ADDRESS);
2125
2126 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2127 orderByComparator);
2128
2129 sql = query.toString();
2130 }
2131 else {
2132 sql = _SQL_SELECT_ADDRESS.concat(AddressModelImpl.ORDER_BY_JPQL);
2133 }
2134
2135 Session session = null;
2136
2137 try {
2138 session = openSession();
2139
2140 Query q = session.createQuery(sql);
2141
2142 if (orderByComparator == null) {
2143 list = (List<Address>)QueryUtil.list(q, getDialect(),
2144 start, end, false);
2145
2146 Collections.sort(list);
2147 }
2148 else {
2149 list = (List<Address>)QueryUtil.list(q, getDialect(),
2150 start, end);
2151 }
2152 }
2153 catch (Exception e) {
2154 throw processException(e);
2155 }
2156 finally {
2157 if (list == null) {
2158 list = new ArrayList<Address>();
2159 }
2160
2161 cacheResult(list);
2162
2163 FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
2164
2165 closeSession(session);
2166 }
2167 }
2168
2169 return list;
2170 }
2171
2172 public void removeByCompanyId(long companyId) throws SystemException {
2173 for (Address address : findByCompanyId(companyId)) {
2174 remove(address);
2175 }
2176 }
2177
2178 public void removeByUserId(long userId) throws SystemException {
2179 for (Address address : findByUserId(userId)) {
2180 remove(address);
2181 }
2182 }
2183
2184 public void removeByC_C(long companyId, long classNameId)
2185 throws SystemException {
2186 for (Address address : findByC_C(companyId, classNameId)) {
2187 remove(address);
2188 }
2189 }
2190
2191 public void removeByC_C_C(long companyId, long classNameId, long classPK)
2192 throws SystemException {
2193 for (Address address : findByC_C_C(companyId, classNameId, classPK)) {
2194 remove(address);
2195 }
2196 }
2197
2198 public void removeByC_C_C_M(long companyId, long classNameId, long classPK,
2199 boolean mailing) throws SystemException {
2200 for (Address address : findByC_C_C_M(companyId, classNameId, classPK,
2201 mailing)) {
2202 remove(address);
2203 }
2204 }
2205
2206 public void removeByC_C_C_P(long companyId, long classNameId, long classPK,
2207 boolean primary) throws SystemException {
2208 for (Address address : findByC_C_C_P(companyId, classNameId, classPK,
2209 primary)) {
2210 remove(address);
2211 }
2212 }
2213
2214 public void removeAll() throws SystemException {
2215 for (Address address : findAll()) {
2216 remove(address);
2217 }
2218 }
2219
2220 public int countByCompanyId(long companyId) throws SystemException {
2221 Object[] finderArgs = new Object[] { companyId };
2222
2223 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_COMPANYID,
2224 finderArgs, this);
2225
2226 if (count == null) {
2227 StringBundler query = new StringBundler(2);
2228
2229 query.append(_SQL_COUNT_ADDRESS_WHERE);
2230
2231 query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
2232
2233 String sql = query.toString();
2234
2235 Session session = null;
2236
2237 try {
2238 session = openSession();
2239
2240 Query q = session.createQuery(sql);
2241
2242 QueryPos qPos = QueryPos.getInstance(q);
2243
2244 qPos.add(companyId);
2245
2246 count = (Long)q.uniqueResult();
2247 }
2248 catch (Exception e) {
2249 throw processException(e);
2250 }
2251 finally {
2252 if (count == null) {
2253 count = Long.valueOf(0);
2254 }
2255
2256 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_COMPANYID,
2257 finderArgs, count);
2258
2259 closeSession(session);
2260 }
2261 }
2262
2263 return count.intValue();
2264 }
2265
2266 public int countByUserId(long userId) throws SystemException {
2267 Object[] finderArgs = new Object[] { userId };
2268
2269 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_USERID,
2270 finderArgs, this);
2271
2272 if (count == null) {
2273 StringBundler query = new StringBundler(2);
2274
2275 query.append(_SQL_COUNT_ADDRESS_WHERE);
2276
2277 query.append(_FINDER_COLUMN_USERID_USERID_2);
2278
2279 String sql = query.toString();
2280
2281 Session session = null;
2282
2283 try {
2284 session = openSession();
2285
2286 Query q = session.createQuery(sql);
2287
2288 QueryPos qPos = QueryPos.getInstance(q);
2289
2290 qPos.add(userId);
2291
2292 count = (Long)q.uniqueResult();
2293 }
2294 catch (Exception e) {
2295 throw processException(e);
2296 }
2297 finally {
2298 if (count == null) {
2299 count = Long.valueOf(0);
2300 }
2301
2302 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_USERID,
2303 finderArgs, count);
2304
2305 closeSession(session);
2306 }
2307 }
2308
2309 return count.intValue();
2310 }
2311
2312 public int countByC_C(long companyId, long classNameId)
2313 throws SystemException {
2314 Object[] finderArgs = new Object[] { companyId, classNameId };
2315
2316 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_C,
2317 finderArgs, this);
2318
2319 if (count == null) {
2320 StringBundler query = new StringBundler(3);
2321
2322 query.append(_SQL_COUNT_ADDRESS_WHERE);
2323
2324 query.append(_FINDER_COLUMN_C_C_COMPANYID_2);
2325
2326 query.append(_FINDER_COLUMN_C_C_CLASSNAMEID_2);
2327
2328 String sql = query.toString();
2329
2330 Session session = null;
2331
2332 try {
2333 session = openSession();
2334
2335 Query q = session.createQuery(sql);
2336
2337 QueryPos qPos = QueryPos.getInstance(q);
2338
2339 qPos.add(companyId);
2340
2341 qPos.add(classNameId);
2342
2343 count = (Long)q.uniqueResult();
2344 }
2345 catch (Exception e) {
2346 throw processException(e);
2347 }
2348 finally {
2349 if (count == null) {
2350 count = Long.valueOf(0);
2351 }
2352
2353 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_C, finderArgs,
2354 count);
2355
2356 closeSession(session);
2357 }
2358 }
2359
2360 return count.intValue();
2361 }
2362
2363 public int countByC_C_C(long companyId, long classNameId, long classPK)
2364 throws SystemException {
2365 Object[] finderArgs = new Object[] { companyId, classNameId, classPK };
2366
2367 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_C_C,
2368 finderArgs, this);
2369
2370 if (count == null) {
2371 StringBundler query = new StringBundler(4);
2372
2373 query.append(_SQL_COUNT_ADDRESS_WHERE);
2374
2375 query.append(_FINDER_COLUMN_C_C_C_COMPANYID_2);
2376
2377 query.append(_FINDER_COLUMN_C_C_C_CLASSNAMEID_2);
2378
2379 query.append(_FINDER_COLUMN_C_C_C_CLASSPK_2);
2380
2381 String sql = query.toString();
2382
2383 Session session = null;
2384
2385 try {
2386 session = openSession();
2387
2388 Query q = session.createQuery(sql);
2389
2390 QueryPos qPos = QueryPos.getInstance(q);
2391
2392 qPos.add(companyId);
2393
2394 qPos.add(classNameId);
2395
2396 qPos.add(classPK);
2397
2398 count = (Long)q.uniqueResult();
2399 }
2400 catch (Exception e) {
2401 throw processException(e);
2402 }
2403 finally {
2404 if (count == null) {
2405 count = Long.valueOf(0);
2406 }
2407
2408 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_C_C,
2409 finderArgs, count);
2410
2411 closeSession(session);
2412 }
2413 }
2414
2415 return count.intValue();
2416 }
2417
2418 public int countByC_C_C_M(long companyId, long classNameId, long classPK,
2419 boolean mailing) throws SystemException {
2420 Object[] finderArgs = new Object[] {
2421 companyId, classNameId, classPK, mailing
2422 };
2423
2424 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_C_C_M,
2425 finderArgs, this);
2426
2427 if (count == null) {
2428 StringBundler query = new StringBundler(5);
2429
2430 query.append(_SQL_COUNT_ADDRESS_WHERE);
2431
2432 query.append(_FINDER_COLUMN_C_C_C_M_COMPANYID_2);
2433
2434 query.append(_FINDER_COLUMN_C_C_C_M_CLASSNAMEID_2);
2435
2436 query.append(_FINDER_COLUMN_C_C_C_M_CLASSPK_2);
2437
2438 query.append(_FINDER_COLUMN_C_C_C_M_MAILING_2);
2439
2440 String sql = query.toString();
2441
2442 Session session = null;
2443
2444 try {
2445 session = openSession();
2446
2447 Query q = session.createQuery(sql);
2448
2449 QueryPos qPos = QueryPos.getInstance(q);
2450
2451 qPos.add(companyId);
2452
2453 qPos.add(classNameId);
2454
2455 qPos.add(classPK);
2456
2457 qPos.add(mailing);
2458
2459 count = (Long)q.uniqueResult();
2460 }
2461 catch (Exception e) {
2462 throw processException(e);
2463 }
2464 finally {
2465 if (count == null) {
2466 count = Long.valueOf(0);
2467 }
2468
2469 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_C_C_M,
2470 finderArgs, count);
2471
2472 closeSession(session);
2473 }
2474 }
2475
2476 return count.intValue();
2477 }
2478
2479 public int countByC_C_C_P(long companyId, long classNameId, long classPK,
2480 boolean primary) throws SystemException {
2481 Object[] finderArgs = new Object[] {
2482 companyId, classNameId, classPK, primary
2483 };
2484
2485 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_C_C_P,
2486 finderArgs, this);
2487
2488 if (count == null) {
2489 StringBundler query = new StringBundler(5);
2490
2491 query.append(_SQL_COUNT_ADDRESS_WHERE);
2492
2493 query.append(_FINDER_COLUMN_C_C_C_P_COMPANYID_2);
2494
2495 query.append(_FINDER_COLUMN_C_C_C_P_CLASSNAMEID_2);
2496
2497 query.append(_FINDER_COLUMN_C_C_C_P_CLASSPK_2);
2498
2499 query.append(_FINDER_COLUMN_C_C_C_P_PRIMARY_2);
2500
2501 String sql = query.toString();
2502
2503 Session session = null;
2504
2505 try {
2506 session = openSession();
2507
2508 Query q = session.createQuery(sql);
2509
2510 QueryPos qPos = QueryPos.getInstance(q);
2511
2512 qPos.add(companyId);
2513
2514 qPos.add(classNameId);
2515
2516 qPos.add(classPK);
2517
2518 qPos.add(primary);
2519
2520 count = (Long)q.uniqueResult();
2521 }
2522 catch (Exception e) {
2523 throw processException(e);
2524 }
2525 finally {
2526 if (count == null) {
2527 count = Long.valueOf(0);
2528 }
2529
2530 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_C_C_P,
2531 finderArgs, count);
2532
2533 closeSession(session);
2534 }
2535 }
2536
2537 return count.intValue();
2538 }
2539
2540 public int countAll() throws SystemException {
2541 Object[] finderArgs = new Object[0];
2542
2543 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
2544 finderArgs, this);
2545
2546 if (count == null) {
2547 Session session = null;
2548
2549 try {
2550 session = openSession();
2551
2552 Query q = session.createQuery(_SQL_COUNT_ADDRESS);
2553
2554 count = (Long)q.uniqueResult();
2555 }
2556 catch (Exception e) {
2557 throw processException(e);
2558 }
2559 finally {
2560 if (count == null) {
2561 count = Long.valueOf(0);
2562 }
2563
2564 FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
2565 count);
2566
2567 closeSession(session);
2568 }
2569 }
2570
2571 return count.intValue();
2572 }
2573
2574 public void afterPropertiesSet() {
2575 String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
2576 com.liferay.portal.util.PropsUtil.get(
2577 "value.object.listener.com.liferay.portal.model.Address")));
2578
2579 if (listenerClassNames.length > 0) {
2580 try {
2581 List<ModelListener<Address>> listenersList = new ArrayList<ModelListener<Address>>();
2582
2583 for (String listenerClassName : listenerClassNames) {
2584 listenersList.add((ModelListener<Address>)InstanceFactory.newInstance(
2585 listenerClassName));
2586 }
2587
2588 listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
2589 }
2590 catch (Exception e) {
2591 _log.error(e);
2592 }
2593 }
2594 }
2595
2596 public void destroy() {
2597 EntityCacheUtil.removeCache(AddressImpl.class.getName());
2598 FinderCacheUtil.removeCache(FINDER_CLASS_NAME_ENTITY);
2599 FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST);
2600 }
2601
2602 @BeanReference(type = AccountPersistence.class)
2603 protected AccountPersistence accountPersistence;
2604 @BeanReference(type = AddressPersistence.class)
2605 protected AddressPersistence addressPersistence;
2606 @BeanReference(type = BrowserTrackerPersistence.class)
2607 protected BrowserTrackerPersistence browserTrackerPersistence;
2608 @BeanReference(type = ClassNamePersistence.class)
2609 protected ClassNamePersistence classNamePersistence;
2610 @BeanReference(type = CompanyPersistence.class)
2611 protected CompanyPersistence companyPersistence;
2612 @BeanReference(type = ContactPersistence.class)
2613 protected ContactPersistence contactPersistence;
2614 @BeanReference(type = CountryPersistence.class)
2615 protected CountryPersistence countryPersistence;
2616 @BeanReference(type = EmailAddressPersistence.class)
2617 protected EmailAddressPersistence emailAddressPersistence;
2618 @BeanReference(type = GroupPersistence.class)
2619 protected GroupPersistence groupPersistence;
2620 @BeanReference(type = ImagePersistence.class)
2621 protected ImagePersistence imagePersistence;
2622 @BeanReference(type = LayoutPersistence.class)
2623 protected LayoutPersistence layoutPersistence;
2624 @BeanReference(type = LayoutSetPersistence.class)
2625 protected LayoutSetPersistence layoutSetPersistence;
2626 @BeanReference(type = ListTypePersistence.class)
2627 protected ListTypePersistence listTypePersistence;
2628 @BeanReference(type = LockPersistence.class)
2629 protected LockPersistence lockPersistence;
2630 @BeanReference(type = MembershipRequestPersistence.class)
2631 protected MembershipRequestPersistence membershipRequestPersistence;
2632 @BeanReference(type = OrganizationPersistence.class)
2633 protected OrganizationPersistence organizationPersistence;
2634 @BeanReference(type = OrgGroupPermissionPersistence.class)
2635 protected OrgGroupPermissionPersistence orgGroupPermissionPersistence;
2636 @BeanReference(type = OrgGroupRolePersistence.class)
2637 protected OrgGroupRolePersistence orgGroupRolePersistence;
2638 @BeanReference(type = OrgLaborPersistence.class)
2639 protected OrgLaborPersistence orgLaborPersistence;
2640 @BeanReference(type = PasswordPolicyPersistence.class)
2641 protected PasswordPolicyPersistence passwordPolicyPersistence;
2642 @BeanReference(type = PasswordPolicyRelPersistence.class)
2643 protected PasswordPolicyRelPersistence passwordPolicyRelPersistence;
2644 @BeanReference(type = PasswordTrackerPersistence.class)
2645 protected PasswordTrackerPersistence passwordTrackerPersistence;
2646 @BeanReference(type = PermissionPersistence.class)
2647 protected PermissionPersistence permissionPersistence;
2648 @BeanReference(type = PhonePersistence.class)
2649 protected PhonePersistence phonePersistence;
2650 @BeanReference(type = PluginSettingPersistence.class)
2651 protected PluginSettingPersistence pluginSettingPersistence;
2652 @BeanReference(type = PortletPersistence.class)
2653 protected PortletPersistence portletPersistence;
2654 @BeanReference(type = PortletItemPersistence.class)
2655 protected PortletItemPersistence portletItemPersistence;
2656 @BeanReference(type = PortletPreferencesPersistence.class)
2657 protected PortletPreferencesPersistence portletPreferencesPersistence;
2658 @BeanReference(type = RegionPersistence.class)
2659 protected RegionPersistence regionPersistence;
2660 @BeanReference(type = ReleasePersistence.class)
2661 protected ReleasePersistence releasePersistence;
2662 @BeanReference(type = ResourcePersistence.class)
2663 protected ResourcePersistence resourcePersistence;
2664 @BeanReference(type = ResourceActionPersistence.class)
2665 protected ResourceActionPersistence resourceActionPersistence;
2666 @BeanReference(type = ResourceCodePersistence.class)
2667 protected ResourceCodePersistence resourceCodePersistence;
2668 @BeanReference(type = ResourcePermissionPersistence.class)
2669 protected ResourcePermissionPersistence resourcePermissionPersistence;
2670 @BeanReference(type = RolePersistence.class)
2671 protected RolePersistence rolePersistence;
2672 @BeanReference(type = ServiceComponentPersistence.class)
2673 protected ServiceComponentPersistence serviceComponentPersistence;
2674 @BeanReference(type = ShardPersistence.class)
2675 protected ShardPersistence shardPersistence;
2676 @BeanReference(type = SubscriptionPersistence.class)
2677 protected SubscriptionPersistence subscriptionPersistence;
2678 @BeanReference(type = UserPersistence.class)
2679 protected UserPersistence userPersistence;
2680 @BeanReference(type = UserGroupPersistence.class)
2681 protected UserGroupPersistence userGroupPersistence;
2682 @BeanReference(type = UserGroupGroupRolePersistence.class)
2683 protected UserGroupGroupRolePersistence userGroupGroupRolePersistence;
2684 @BeanReference(type = UserGroupRolePersistence.class)
2685 protected UserGroupRolePersistence userGroupRolePersistence;
2686 @BeanReference(type = UserIdMapperPersistence.class)
2687 protected UserIdMapperPersistence userIdMapperPersistence;
2688 @BeanReference(type = UserTrackerPersistence.class)
2689 protected UserTrackerPersistence userTrackerPersistence;
2690 @BeanReference(type = UserTrackerPathPersistence.class)
2691 protected UserTrackerPathPersistence userTrackerPathPersistence;
2692 @BeanReference(type = WebDAVPropsPersistence.class)
2693 protected WebDAVPropsPersistence webDAVPropsPersistence;
2694 @BeanReference(type = WebsitePersistence.class)
2695 protected WebsitePersistence websitePersistence;
2696 private static final String _SQL_SELECT_ADDRESS = "SELECT address FROM Address address";
2697 private static final String _SQL_SELECT_ADDRESS_WHERE = "SELECT address FROM Address address WHERE ";
2698 private static final String _SQL_COUNT_ADDRESS = "SELECT COUNT(address) FROM Address address";
2699 private static final String _SQL_COUNT_ADDRESS_WHERE = "SELECT COUNT(address) FROM Address address WHERE ";
2700 private static final String _FINDER_COLUMN_COMPANYID_COMPANYID_2 = "address.companyId = ?";
2701 private static final String _FINDER_COLUMN_USERID_USERID_2 = "address.userId = ?";
2702 private static final String _FINDER_COLUMN_C_C_COMPANYID_2 = "address.companyId = ? AND ";
2703 private static final String _FINDER_COLUMN_C_C_CLASSNAMEID_2 = "address.classNameId = ?";
2704 private static final String _FINDER_COLUMN_C_C_C_COMPANYID_2 = "address.companyId = ? AND ";
2705 private static final String _FINDER_COLUMN_C_C_C_CLASSNAMEID_2 = "address.classNameId = ? AND ";
2706 private static final String _FINDER_COLUMN_C_C_C_CLASSPK_2 = "address.classPK = ?";
2707 private static final String _FINDER_COLUMN_C_C_C_M_COMPANYID_2 = "address.companyId = ? AND ";
2708 private static final String _FINDER_COLUMN_C_C_C_M_CLASSNAMEID_2 = "address.classNameId = ? AND ";
2709 private static final String _FINDER_COLUMN_C_C_C_M_CLASSPK_2 = "address.classPK = ? AND ";
2710 private static final String _FINDER_COLUMN_C_C_C_M_MAILING_2 = "address.mailing = ?";
2711 private static final String _FINDER_COLUMN_C_C_C_P_COMPANYID_2 = "address.companyId = ? AND ";
2712 private static final String _FINDER_COLUMN_C_C_C_P_CLASSNAMEID_2 = "address.classNameId = ? AND ";
2713 private static final String _FINDER_COLUMN_C_C_C_P_CLASSPK_2 = "address.classPK = ? AND ";
2714 private static final String _FINDER_COLUMN_C_C_C_P_PRIMARY_2 = "address.primary = ?";
2715 private static final String _ORDER_BY_ENTITY_ALIAS = "address.";
2716 private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No Address exists with the primary key ";
2717 private static final String _NO_SUCH_ENTITY_WITH_KEY = "No Address exists with the key {";
2718 private static Log _log = LogFactoryUtil.getLog(AddressPersistenceImpl.class);
2719}