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