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