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