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