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