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