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