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