1   /**
2    * Copyright (c) 2000-2008 Liferay, Inc. All rights reserved.
3    *
4    * Permission is hereby granted, free of charge, to any person obtaining a copy
5    * of this software and associated documentation files (the "Software"), to deal
6    * in the Software without restriction, including without limitation the rights
7    * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8    * copies of the Software, and to permit persons to whom the Software is
9    * furnished to do so, subject to the following conditions:
10   *
11   * The above copyright notice and this permission notice shall be included in
12   * all copies or substantial portions of the Software.
13   *
14   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20   * SOFTWARE.
21   */
22  
23  package com.liferay.portal.service.persistence;
24  
25  import com.liferay.portal.NoSuchEmailAddressException;
26  import com.liferay.portal.SystemException;
27  import com.liferay.portal.kernel.dao.DynamicQuery;
28  import com.liferay.portal.kernel.dao.DynamicQueryInitializer;
29  import com.liferay.portal.kernel.util.GetterUtil;
30  import com.liferay.portal.kernel.util.OrderByComparator;
31  import com.liferay.portal.kernel.util.StringMaker;
32  import com.liferay.portal.kernel.util.StringPool;
33  import com.liferay.portal.kernel.util.Validator;
34  import com.liferay.portal.model.EmailAddress;
35  import com.liferay.portal.model.ModelListener;
36  import com.liferay.portal.model.impl.EmailAddressImpl;
37  import com.liferay.portal.model.impl.EmailAddressModelImpl;
38  import com.liferay.portal.spring.hibernate.FinderCache;
39  import com.liferay.portal.spring.hibernate.HibernateUtil;
40  import com.liferay.portal.util.PropsUtil;
41  
42  import com.liferay.util.dao.hibernate.QueryUtil;
43  
44  import org.apache.commons.logging.Log;
45  import org.apache.commons.logging.LogFactory;
46  
47  import org.hibernate.Query;
48  import org.hibernate.Session;
49  
50  import java.util.Collections;
51  import java.util.Iterator;
52  import java.util.List;
53  
54  /**
55   * <a href="EmailAddressPersistenceImpl.java.html"><b><i>View Source</i></b></a>
56   *
57   * @author Brian Wing Shun Chan
58   *
59   */
60  public class EmailAddressPersistenceImpl extends BasePersistence
61      implements EmailAddressPersistence {
62      public EmailAddress create(long emailAddressId) {
63          EmailAddress emailAddress = new EmailAddressImpl();
64  
65          emailAddress.setNew(true);
66          emailAddress.setPrimaryKey(emailAddressId);
67  
68          return emailAddress;
69      }
70  
71      public EmailAddress remove(long emailAddressId)
72          throws NoSuchEmailAddressException, SystemException {
73          Session session = null;
74  
75          try {
76              session = openSession();
77  
78              EmailAddress emailAddress = (EmailAddress)session.get(EmailAddressImpl.class,
79                      new Long(emailAddressId));
80  
81              if (emailAddress == null) {
82                  if (_log.isWarnEnabled()) {
83                      _log.warn("No EmailAddress exists with the primary key " +
84                          emailAddressId);
85                  }
86  
87                  throw new NoSuchEmailAddressException(
88                      "No EmailAddress exists with the primary key " +
89                      emailAddressId);
90              }
91  
92              return remove(emailAddress);
93          }
94          catch (NoSuchEmailAddressException nsee) {
95              throw nsee;
96          }
97          catch (Exception e) {
98              throw HibernateUtil.processException(e);
99          }
100         finally {
101             closeSession(session);
102         }
103     }
104 
105     public EmailAddress remove(EmailAddress emailAddress)
106         throws SystemException {
107         ModelListener listener = _getListener();
108 
109         if (listener != null) {
110             listener.onBeforeRemove(emailAddress);
111         }
112 
113         emailAddress = removeImpl(emailAddress);
114 
115         if (listener != null) {
116             listener.onAfterRemove(emailAddress);
117         }
118 
119         return emailAddress;
120     }
121 
122     protected EmailAddress removeImpl(EmailAddress emailAddress)
123         throws SystemException {
124         Session session = null;
125 
126         try {
127             session = openSession();
128 
129             session.delete(emailAddress);
130 
131             session.flush();
132 
133             return emailAddress;
134         }
135         catch (Exception e) {
136             throw HibernateUtil.processException(e);
137         }
138         finally {
139             closeSession(session);
140 
141             FinderCache.clearCache(EmailAddress.class.getName());
142         }
143     }
144 
145     public EmailAddress update(EmailAddress emailAddress)
146         throws SystemException {
147         return update(emailAddress, false);
148     }
149 
150     public EmailAddress update(EmailAddress emailAddress, boolean merge)
151         throws SystemException {
152         ModelListener listener = _getListener();
153 
154         boolean isNew = emailAddress.isNew();
155 
156         if (listener != null) {
157             if (isNew) {
158                 listener.onBeforeCreate(emailAddress);
159             }
160             else {
161                 listener.onBeforeUpdate(emailAddress);
162             }
163         }
164 
165         emailAddress = updateImpl(emailAddress, merge);
166 
167         if (listener != null) {
168             if (isNew) {
169                 listener.onAfterCreate(emailAddress);
170             }
171             else {
172                 listener.onAfterUpdate(emailAddress);
173             }
174         }
175 
176         return emailAddress;
177     }
178 
179     public EmailAddress updateImpl(
180         com.liferay.portal.model.EmailAddress emailAddress, boolean merge)
181         throws SystemException {
182         Session session = null;
183 
184         try {
185             session = openSession();
186 
187             if (merge) {
188                 session.merge(emailAddress);
189             }
190             else {
191                 if (emailAddress.isNew()) {
192                     session.save(emailAddress);
193                 }
194             }
195 
196             session.flush();
197 
198             emailAddress.setNew(false);
199 
200             return emailAddress;
201         }
202         catch (Exception e) {
203             throw HibernateUtil.processException(e);
204         }
205         finally {
206             closeSession(session);
207 
208             FinderCache.clearCache(EmailAddress.class.getName());
209         }
210     }
211 
212     public EmailAddress findByPrimaryKey(long emailAddressId)
213         throws NoSuchEmailAddressException, SystemException {
214         EmailAddress emailAddress = fetchByPrimaryKey(emailAddressId);
215 
216         if (emailAddress == null) {
217             if (_log.isWarnEnabled()) {
218                 _log.warn("No EmailAddress exists with the primary key " +
219                     emailAddressId);
220             }
221 
222             throw new NoSuchEmailAddressException(
223                 "No EmailAddress exists with the primary key " +
224                 emailAddressId);
225         }
226 
227         return emailAddress;
228     }
229 
230     public EmailAddress fetchByPrimaryKey(long emailAddressId)
231         throws SystemException {
232         Session session = null;
233 
234         try {
235             session = openSession();
236 
237             return (EmailAddress)session.get(EmailAddressImpl.class,
238                 new Long(emailAddressId));
239         }
240         catch (Exception e) {
241             throw HibernateUtil.processException(e);
242         }
243         finally {
244             closeSession(session);
245         }
246     }
247 
248     public List findByCompanyId(long companyId) throws SystemException {
249         boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
250         String finderClassName = EmailAddress.class.getName();
251         String finderMethodName = "findByCompanyId";
252         String[] finderParams = new String[] { Long.class.getName() };
253         Object[] finderArgs = new Object[] { new Long(companyId) };
254 
255         Object result = null;
256 
257         if (finderClassNameCacheEnabled) {
258             result = FinderCache.getResult(finderClassName, finderMethodName,
259                     finderParams, finderArgs, getSessionFactory());
260         }
261 
262         if (result == null) {
263             Session session = null;
264 
265             try {
266                 session = openSession();
267 
268                 StringMaker query = new StringMaker();
269 
270                 query.append(
271                     "FROM com.liferay.portal.model.EmailAddress WHERE ");
272 
273                 query.append("companyId = ?");
274 
275                 query.append(" ");
276 
277                 query.append("ORDER BY ");
278 
279                 query.append("createDate ASC");
280 
281                 Query q = session.createQuery(query.toString());
282 
283                 int queryPos = 0;
284 
285                 q.setLong(queryPos++, companyId);
286 
287                 List list = q.list();
288 
289                 FinderCache.putResult(finderClassNameCacheEnabled,
290                     finderClassName, finderMethodName, finderParams,
291                     finderArgs, list);
292 
293                 return list;
294             }
295             catch (Exception e) {
296                 throw HibernateUtil.processException(e);
297             }
298             finally {
299                 closeSession(session);
300             }
301         }
302         else {
303             return (List)result;
304         }
305     }
306 
307     public List findByCompanyId(long companyId, int begin, int end)
308         throws SystemException {
309         return findByCompanyId(companyId, begin, end, null);
310     }
311 
312     public List findByCompanyId(long companyId, int begin, int end,
313         OrderByComparator obc) throws SystemException {
314         boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
315         String finderClassName = EmailAddress.class.getName();
316         String finderMethodName = "findByCompanyId";
317         String[] finderParams = new String[] {
318                 Long.class.getName(),
319                 
320                 "java.lang.Integer", "java.lang.Integer",
321                 "com.liferay.portal.kernel.util.OrderByComparator"
322             };
323         Object[] finderArgs = new Object[] {
324                 new Long(companyId),
325                 
326                 String.valueOf(begin), String.valueOf(end), String.valueOf(obc)
327             };
328 
329         Object result = null;
330 
331         if (finderClassNameCacheEnabled) {
332             result = FinderCache.getResult(finderClassName, finderMethodName,
333                     finderParams, finderArgs, getSessionFactory());
334         }
335 
336         if (result == null) {
337             Session session = null;
338 
339             try {
340                 session = openSession();
341 
342                 StringMaker query = new StringMaker();
343 
344                 query.append(
345                     "FROM com.liferay.portal.model.EmailAddress WHERE ");
346 
347                 query.append("companyId = ?");
348 
349                 query.append(" ");
350 
351                 if (obc != null) {
352                     query.append("ORDER BY ");
353                     query.append(obc.getOrderBy());
354                 }
355 
356                 else {
357                     query.append("ORDER BY ");
358 
359                     query.append("createDate ASC");
360                 }
361 
362                 Query q = session.createQuery(query.toString());
363 
364                 int queryPos = 0;
365 
366                 q.setLong(queryPos++, companyId);
367 
368                 List list = QueryUtil.list(q, getDialect(), begin, end);
369 
370                 FinderCache.putResult(finderClassNameCacheEnabled,
371                     finderClassName, finderMethodName, finderParams,
372                     finderArgs, list);
373 
374                 return list;
375             }
376             catch (Exception e) {
377                 throw HibernateUtil.processException(e);
378             }
379             finally {
380                 closeSession(session);
381             }
382         }
383         else {
384             return (List)result;
385         }
386     }
387 
388     public EmailAddress findByCompanyId_First(long companyId,
389         OrderByComparator obc)
390         throws NoSuchEmailAddressException, SystemException {
391         List list = findByCompanyId(companyId, 0, 1, obc);
392 
393         if (list.size() == 0) {
394             StringMaker msg = new StringMaker();
395 
396             msg.append("No EmailAddress exists with the key {");
397 
398             msg.append("companyId=" + companyId);
399 
400             msg.append(StringPool.CLOSE_CURLY_BRACE);
401 
402             throw new NoSuchEmailAddressException(msg.toString());
403         }
404         else {
405             return (EmailAddress)list.get(0);
406         }
407     }
408 
409     public EmailAddress findByCompanyId_Last(long companyId,
410         OrderByComparator obc)
411         throws NoSuchEmailAddressException, SystemException {
412         int count = countByCompanyId(companyId);
413 
414         List list = findByCompanyId(companyId, count - 1, count, obc);
415 
416         if (list.size() == 0) {
417             StringMaker msg = new StringMaker();
418 
419             msg.append("No EmailAddress exists with the key {");
420 
421             msg.append("companyId=" + companyId);
422 
423             msg.append(StringPool.CLOSE_CURLY_BRACE);
424 
425             throw new NoSuchEmailAddressException(msg.toString());
426         }
427         else {
428             return (EmailAddress)list.get(0);
429         }
430     }
431 
432     public EmailAddress[] findByCompanyId_PrevAndNext(long emailAddressId,
433         long companyId, OrderByComparator obc)
434         throws NoSuchEmailAddressException, SystemException {
435         EmailAddress emailAddress = findByPrimaryKey(emailAddressId);
436 
437         int count = countByCompanyId(companyId);
438 
439         Session session = null;
440 
441         try {
442             session = openSession();
443 
444             StringMaker query = new StringMaker();
445 
446             query.append("FROM com.liferay.portal.model.EmailAddress WHERE ");
447 
448             query.append("companyId = ?");
449 
450             query.append(" ");
451 
452             if (obc != null) {
453                 query.append("ORDER BY ");
454                 query.append(obc.getOrderBy());
455             }
456 
457             else {
458                 query.append("ORDER BY ");
459 
460                 query.append("createDate ASC");
461             }
462 
463             Query q = session.createQuery(query.toString());
464 
465             int queryPos = 0;
466 
467             q.setLong(queryPos++, companyId);
468 
469             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
470                     emailAddress);
471 
472             EmailAddress[] array = new EmailAddressImpl[3];
473 
474             array[0] = (EmailAddress)objArray[0];
475             array[1] = (EmailAddress)objArray[1];
476             array[2] = (EmailAddress)objArray[2];
477 
478             return array;
479         }
480         catch (Exception e) {
481             throw HibernateUtil.processException(e);
482         }
483         finally {
484             closeSession(session);
485         }
486     }
487 
488     public List findByUserId(long userId) throws SystemException {
489         boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
490         String finderClassName = EmailAddress.class.getName();
491         String finderMethodName = "findByUserId";
492         String[] finderParams = new String[] { Long.class.getName() };
493         Object[] finderArgs = new Object[] { new Long(userId) };
494 
495         Object result = null;
496 
497         if (finderClassNameCacheEnabled) {
498             result = FinderCache.getResult(finderClassName, finderMethodName,
499                     finderParams, finderArgs, getSessionFactory());
500         }
501 
502         if (result == null) {
503             Session session = null;
504 
505             try {
506                 session = openSession();
507 
508                 StringMaker query = new StringMaker();
509 
510                 query.append(
511                     "FROM com.liferay.portal.model.EmailAddress WHERE ");
512 
513                 query.append("userId = ?");
514 
515                 query.append(" ");
516 
517                 query.append("ORDER BY ");
518 
519                 query.append("createDate ASC");
520 
521                 Query q = session.createQuery(query.toString());
522 
523                 int queryPos = 0;
524 
525                 q.setLong(queryPos++, userId);
526 
527                 List list = q.list();
528 
529                 FinderCache.putResult(finderClassNameCacheEnabled,
530                     finderClassName, finderMethodName, finderParams,
531                     finderArgs, list);
532 
533                 return list;
534             }
535             catch (Exception e) {
536                 throw HibernateUtil.processException(e);
537             }
538             finally {
539                 closeSession(session);
540             }
541         }
542         else {
543             return (List)result;
544         }
545     }
546 
547     public List findByUserId(long userId, int begin, int end)
548         throws SystemException {
549         return findByUserId(userId, begin, end, null);
550     }
551 
552     public List findByUserId(long userId, int begin, int end,
553         OrderByComparator obc) throws SystemException {
554         boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
555         String finderClassName = EmailAddress.class.getName();
556         String finderMethodName = "findByUserId";
557         String[] finderParams = new String[] {
558                 Long.class.getName(),
559                 
560                 "java.lang.Integer", "java.lang.Integer",
561                 "com.liferay.portal.kernel.util.OrderByComparator"
562             };
563         Object[] finderArgs = new Object[] {
564                 new Long(userId),
565                 
566                 String.valueOf(begin), String.valueOf(end), String.valueOf(obc)
567             };
568 
569         Object result = null;
570 
571         if (finderClassNameCacheEnabled) {
572             result = FinderCache.getResult(finderClassName, finderMethodName,
573                     finderParams, finderArgs, getSessionFactory());
574         }
575 
576         if (result == null) {
577             Session session = null;
578 
579             try {
580                 session = openSession();
581 
582                 StringMaker query = new StringMaker();
583 
584                 query.append(
585                     "FROM com.liferay.portal.model.EmailAddress WHERE ");
586 
587                 query.append("userId = ?");
588 
589                 query.append(" ");
590 
591                 if (obc != null) {
592                     query.append("ORDER BY ");
593                     query.append(obc.getOrderBy());
594                 }
595 
596                 else {
597                     query.append("ORDER BY ");
598 
599                     query.append("createDate ASC");
600                 }
601 
602                 Query q = session.createQuery(query.toString());
603 
604                 int queryPos = 0;
605 
606                 q.setLong(queryPos++, userId);
607 
608                 List list = QueryUtil.list(q, getDialect(), begin, end);
609 
610                 FinderCache.putResult(finderClassNameCacheEnabled,
611                     finderClassName, finderMethodName, finderParams,
612                     finderArgs, list);
613 
614                 return list;
615             }
616             catch (Exception e) {
617                 throw HibernateUtil.processException(e);
618             }
619             finally {
620                 closeSession(session);
621             }
622         }
623         else {
624             return (List)result;
625         }
626     }
627 
628     public EmailAddress findByUserId_First(long userId, OrderByComparator obc)
629         throws NoSuchEmailAddressException, SystemException {
630         List list = findByUserId(userId, 0, 1, obc);
631 
632         if (list.size() == 0) {
633             StringMaker msg = new StringMaker();
634 
635             msg.append("No EmailAddress exists with the key {");
636 
637             msg.append("userId=" + userId);
638 
639             msg.append(StringPool.CLOSE_CURLY_BRACE);
640 
641             throw new NoSuchEmailAddressException(msg.toString());
642         }
643         else {
644             return (EmailAddress)list.get(0);
645         }
646     }
647 
648     public EmailAddress findByUserId_Last(long userId, OrderByComparator obc)
649         throws NoSuchEmailAddressException, SystemException {
650         int count = countByUserId(userId);
651 
652         List list = findByUserId(userId, count - 1, count, obc);
653 
654         if (list.size() == 0) {
655             StringMaker msg = new StringMaker();
656 
657             msg.append("No EmailAddress exists with the key {");
658 
659             msg.append("userId=" + userId);
660 
661             msg.append(StringPool.CLOSE_CURLY_BRACE);
662 
663             throw new NoSuchEmailAddressException(msg.toString());
664         }
665         else {
666             return (EmailAddress)list.get(0);
667         }
668     }
669 
670     public EmailAddress[] findByUserId_PrevAndNext(long emailAddressId,
671         long userId, OrderByComparator obc)
672         throws NoSuchEmailAddressException, SystemException {
673         EmailAddress emailAddress = findByPrimaryKey(emailAddressId);
674 
675         int count = countByUserId(userId);
676 
677         Session session = null;
678 
679         try {
680             session = openSession();
681 
682             StringMaker query = new StringMaker();
683 
684             query.append("FROM com.liferay.portal.model.EmailAddress WHERE ");
685 
686             query.append("userId = ?");
687 
688             query.append(" ");
689 
690             if (obc != null) {
691                 query.append("ORDER BY ");
692                 query.append(obc.getOrderBy());
693             }
694 
695             else {
696                 query.append("ORDER BY ");
697 
698                 query.append("createDate ASC");
699             }
700 
701             Query q = session.createQuery(query.toString());
702 
703             int queryPos = 0;
704 
705             q.setLong(queryPos++, userId);
706 
707             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
708                     emailAddress);
709 
710             EmailAddress[] array = new EmailAddressImpl[3];
711 
712             array[0] = (EmailAddress)objArray[0];
713             array[1] = (EmailAddress)objArray[1];
714             array[2] = (EmailAddress)objArray[2];
715 
716             return array;
717         }
718         catch (Exception e) {
719             throw HibernateUtil.processException(e);
720         }
721         finally {
722             closeSession(session);
723         }
724     }
725 
726     public List findByC_C(long companyId, long classNameId)
727         throws SystemException {
728         boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
729         String finderClassName = EmailAddress.class.getName();
730         String finderMethodName = "findByC_C";
731         String[] finderParams = new String[] {
732                 Long.class.getName(), Long.class.getName()
733             };
734         Object[] finderArgs = new Object[] {
735                 new Long(companyId), new Long(classNameId)
736             };
737 
738         Object result = null;
739 
740         if (finderClassNameCacheEnabled) {
741             result = FinderCache.getResult(finderClassName, finderMethodName,
742                     finderParams, finderArgs, getSessionFactory());
743         }
744 
745         if (result == null) {
746             Session session = null;
747 
748             try {
749                 session = openSession();
750 
751                 StringMaker query = new StringMaker();
752 
753                 query.append(
754                     "FROM com.liferay.portal.model.EmailAddress WHERE ");
755 
756                 query.append("companyId = ?");
757 
758                 query.append(" AND ");
759 
760                 query.append("classNameId = ?");
761 
762                 query.append(" ");
763 
764                 query.append("ORDER BY ");
765 
766                 query.append("createDate ASC");
767 
768                 Query q = session.createQuery(query.toString());
769 
770                 int queryPos = 0;
771 
772                 q.setLong(queryPos++, companyId);
773 
774                 q.setLong(queryPos++, classNameId);
775 
776                 List list = q.list();
777 
778                 FinderCache.putResult(finderClassNameCacheEnabled,
779                     finderClassName, finderMethodName, finderParams,
780                     finderArgs, list);
781 
782                 return list;
783             }
784             catch (Exception e) {
785                 throw HibernateUtil.processException(e);
786             }
787             finally {
788                 closeSession(session);
789             }
790         }
791         else {
792             return (List)result;
793         }
794     }
795 
796     public List findByC_C(long companyId, long classNameId, int begin, int end)
797         throws SystemException {
798         return findByC_C(companyId, classNameId, begin, end, null);
799     }
800 
801     public List findByC_C(long companyId, long classNameId, int begin, int end,
802         OrderByComparator obc) throws SystemException {
803         boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
804         String finderClassName = EmailAddress.class.getName();
805         String finderMethodName = "findByC_C";
806         String[] finderParams = new String[] {
807                 Long.class.getName(), Long.class.getName(),
808                 
809                 "java.lang.Integer", "java.lang.Integer",
810                 "com.liferay.portal.kernel.util.OrderByComparator"
811             };
812         Object[] finderArgs = new Object[] {
813                 new Long(companyId), new Long(classNameId),
814                 
815                 String.valueOf(begin), String.valueOf(end), String.valueOf(obc)
816             };
817 
818         Object result = null;
819 
820         if (finderClassNameCacheEnabled) {
821             result = FinderCache.getResult(finderClassName, finderMethodName,
822                     finderParams, finderArgs, getSessionFactory());
823         }
824 
825         if (result == null) {
826             Session session = null;
827 
828             try {
829                 session = openSession();
830 
831                 StringMaker query = new StringMaker();
832 
833                 query.append(
834                     "FROM com.liferay.portal.model.EmailAddress WHERE ");
835 
836                 query.append("companyId = ?");
837 
838                 query.append(" AND ");
839 
840                 query.append("classNameId = ?");
841 
842                 query.append(" ");
843 
844                 if (obc != null) {
845                     query.append("ORDER BY ");
846                     query.append(obc.getOrderBy());
847                 }
848 
849                 else {
850                     query.append("ORDER BY ");
851 
852                     query.append("createDate ASC");
853                 }
854 
855                 Query q = session.createQuery(query.toString());
856 
857                 int queryPos = 0;
858 
859                 q.setLong(queryPos++, companyId);
860 
861                 q.setLong(queryPos++, classNameId);
862 
863                 List list = QueryUtil.list(q, getDialect(), begin, end);
864 
865                 FinderCache.putResult(finderClassNameCacheEnabled,
866                     finderClassName, finderMethodName, finderParams,
867                     finderArgs, list);
868 
869                 return list;
870             }
871             catch (Exception e) {
872                 throw HibernateUtil.processException(e);
873             }
874             finally {
875                 closeSession(session);
876             }
877         }
878         else {
879             return (List)result;
880         }
881     }
882 
883     public EmailAddress findByC_C_First(long companyId, long classNameId,
884         OrderByComparator obc)
885         throws NoSuchEmailAddressException, SystemException {
886         List list = findByC_C(companyId, classNameId, 0, 1, obc);
887 
888         if (list.size() == 0) {
889             StringMaker msg = new StringMaker();
890 
891             msg.append("No EmailAddress exists with the key {");
892 
893             msg.append("companyId=" + companyId);
894 
895             msg.append(", ");
896             msg.append("classNameId=" + classNameId);
897 
898             msg.append(StringPool.CLOSE_CURLY_BRACE);
899 
900             throw new NoSuchEmailAddressException(msg.toString());
901         }
902         else {
903             return (EmailAddress)list.get(0);
904         }
905     }
906 
907     public EmailAddress findByC_C_Last(long companyId, long classNameId,
908         OrderByComparator obc)
909         throws NoSuchEmailAddressException, SystemException {
910         int count = countByC_C(companyId, classNameId);
911 
912         List list = findByC_C(companyId, classNameId, count - 1, count, obc);
913 
914         if (list.size() == 0) {
915             StringMaker msg = new StringMaker();
916 
917             msg.append("No EmailAddress exists with the key {");
918 
919             msg.append("companyId=" + companyId);
920 
921             msg.append(", ");
922             msg.append("classNameId=" + classNameId);
923 
924             msg.append(StringPool.CLOSE_CURLY_BRACE);
925 
926             throw new NoSuchEmailAddressException(msg.toString());
927         }
928         else {
929             return (EmailAddress)list.get(0);
930         }
931     }
932 
933     public EmailAddress[] findByC_C_PrevAndNext(long emailAddressId,
934         long companyId, long classNameId, OrderByComparator obc)
935         throws NoSuchEmailAddressException, SystemException {
936         EmailAddress emailAddress = findByPrimaryKey(emailAddressId);
937 
938         int count = countByC_C(companyId, classNameId);
939 
940         Session session = null;
941 
942         try {
943             session = openSession();
944 
945             StringMaker query = new StringMaker();
946 
947             query.append("FROM com.liferay.portal.model.EmailAddress WHERE ");
948 
949             query.append("companyId = ?");
950 
951             query.append(" AND ");
952 
953             query.append("classNameId = ?");
954 
955             query.append(" ");
956 
957             if (obc != null) {
958                 query.append("ORDER BY ");
959                 query.append(obc.getOrderBy());
960             }
961 
962             else {
963                 query.append("ORDER BY ");
964 
965                 query.append("createDate ASC");
966             }
967 
968             Query q = session.createQuery(query.toString());
969 
970             int queryPos = 0;
971 
972             q.setLong(queryPos++, companyId);
973 
974             q.setLong(queryPos++, classNameId);
975 
976             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
977                     emailAddress);
978 
979             EmailAddress[] array = new EmailAddressImpl[3];
980 
981             array[0] = (EmailAddress)objArray[0];
982             array[1] = (EmailAddress)objArray[1];
983             array[2] = (EmailAddress)objArray[2];
984 
985             return array;
986         }
987         catch (Exception e) {
988             throw HibernateUtil.processException(e);
989         }
990         finally {
991             closeSession(session);
992         }
993     }
994 
995     public List findByC_C_C(long companyId, long classNameId, long classPK)
996         throws SystemException {
997         boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
998         String finderClassName = EmailAddress.class.getName();
999         String finderMethodName = "findByC_C_C";
1000        String[] finderParams = new String[] {
1001                Long.class.getName(), Long.class.getName(), Long.class.getName()
1002            };
1003        Object[] finderArgs = new Object[] {
1004                new Long(companyId), new Long(classNameId), new Long(classPK)
1005            };
1006
1007        Object result = null;
1008
1009        if (finderClassNameCacheEnabled) {
1010            result = FinderCache.getResult(finderClassName, finderMethodName,
1011                    finderParams, finderArgs, getSessionFactory());
1012        }
1013
1014        if (result == null) {
1015            Session session = null;
1016
1017            try {
1018                session = openSession();
1019
1020                StringMaker query = new StringMaker();
1021
1022                query.append(
1023                    "FROM com.liferay.portal.model.EmailAddress WHERE ");
1024
1025                query.append("companyId = ?");
1026
1027                query.append(" AND ");
1028
1029                query.append("classNameId = ?");
1030
1031                query.append(" AND ");
1032
1033                query.append("classPK = ?");
1034
1035                query.append(" ");
1036
1037                query.append("ORDER BY ");
1038
1039                query.append("createDate ASC");
1040
1041                Query q = session.createQuery(query.toString());
1042
1043                int queryPos = 0;
1044
1045                q.setLong(queryPos++, companyId);
1046
1047                q.setLong(queryPos++, classNameId);
1048
1049                q.setLong(queryPos++, classPK);
1050
1051                List list = q.list();
1052
1053                FinderCache.putResult(finderClassNameCacheEnabled,
1054                    finderClassName, finderMethodName, finderParams,
1055                    finderArgs, list);
1056
1057                return list;
1058            }
1059            catch (Exception e) {
1060                throw HibernateUtil.processException(e);
1061            }
1062            finally {
1063                closeSession(session);
1064            }
1065        }
1066        else {
1067            return (List)result;
1068        }
1069    }
1070
1071    public List findByC_C_C(long companyId, long classNameId, long classPK,
1072        int begin, int end) throws SystemException {
1073        return findByC_C_C(companyId, classNameId, classPK, begin, end, null);
1074    }
1075
1076    public List findByC_C_C(long companyId, long classNameId, long classPK,
1077        int begin, int end, OrderByComparator obc) throws SystemException {
1078        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
1079        String finderClassName = EmailAddress.class.getName();
1080        String finderMethodName = "findByC_C_C";
1081        String[] finderParams = new String[] {
1082                Long.class.getName(), Long.class.getName(), Long.class.getName(),
1083                
1084                "java.lang.Integer", "java.lang.Integer",
1085                "com.liferay.portal.kernel.util.OrderByComparator"
1086            };
1087        Object[] finderArgs = new Object[] {
1088                new Long(companyId), new Long(classNameId), new Long(classPK),
1089                
1090                String.valueOf(begin), String.valueOf(end), String.valueOf(obc)
1091            };
1092
1093        Object result = null;
1094
1095        if (finderClassNameCacheEnabled) {
1096            result = FinderCache.getResult(finderClassName, finderMethodName,
1097                    finderParams, finderArgs, getSessionFactory());
1098        }
1099
1100        if (result == null) {
1101            Session session = null;
1102
1103            try {
1104                session = openSession();
1105
1106                StringMaker query = new StringMaker();
1107
1108                query.append(
1109                    "FROM com.liferay.portal.model.EmailAddress WHERE ");
1110
1111                query.append("companyId = ?");
1112
1113                query.append(" AND ");
1114
1115                query.append("classNameId = ?");
1116
1117                query.append(" AND ");
1118
1119                query.append("classPK = ?");
1120
1121                query.append(" ");
1122
1123                if (obc != null) {
1124                    query.append("ORDER BY ");
1125                    query.append(obc.getOrderBy());
1126                }
1127
1128                else {
1129                    query.append("ORDER BY ");
1130
1131                    query.append("createDate ASC");
1132                }
1133
1134                Query q = session.createQuery(query.toString());
1135
1136                int queryPos = 0;
1137
1138                q.setLong(queryPos++, companyId);
1139
1140                q.setLong(queryPos++, classNameId);
1141
1142                q.setLong(queryPos++, classPK);
1143
1144                List list = QueryUtil.list(q, getDialect(), begin, end);
1145
1146                FinderCache.putResult(finderClassNameCacheEnabled,
1147                    finderClassName, finderMethodName, finderParams,
1148                    finderArgs, list);
1149
1150                return list;
1151            }
1152            catch (Exception e) {
1153                throw HibernateUtil.processException(e);
1154            }
1155            finally {
1156                closeSession(session);
1157            }
1158        }
1159        else {
1160            return (List)result;
1161        }
1162    }
1163
1164    public EmailAddress findByC_C_C_First(long companyId, long classNameId,
1165        long classPK, OrderByComparator obc)
1166        throws NoSuchEmailAddressException, SystemException {
1167        List list = findByC_C_C(companyId, classNameId, classPK, 0, 1, obc);
1168
1169        if (list.size() == 0) {
1170            StringMaker msg = new StringMaker();
1171
1172            msg.append("No EmailAddress exists with the key {");
1173
1174            msg.append("companyId=" + companyId);
1175
1176            msg.append(", ");
1177            msg.append("classNameId=" + classNameId);
1178
1179            msg.append(", ");
1180            msg.append("classPK=" + classPK);
1181
1182            msg.append(StringPool.CLOSE_CURLY_BRACE);
1183
1184            throw new NoSuchEmailAddressException(msg.toString());
1185        }
1186        else {
1187            return (EmailAddress)list.get(0);
1188        }
1189    }
1190
1191    public EmailAddress findByC_C_C_Last(long companyId, long classNameId,
1192        long classPK, OrderByComparator obc)
1193        throws NoSuchEmailAddressException, SystemException {
1194        int count = countByC_C_C(companyId, classNameId, classPK);
1195
1196        List list = findByC_C_C(companyId, classNameId, classPK, count - 1,
1197                count, obc);
1198
1199        if (list.size() == 0) {
1200            StringMaker msg = new StringMaker();
1201
1202            msg.append("No EmailAddress exists with the key {");
1203
1204            msg.append("companyId=" + companyId);
1205
1206            msg.append(", ");
1207            msg.append("classNameId=" + classNameId);
1208
1209            msg.append(", ");
1210            msg.append("classPK=" + classPK);
1211
1212            msg.append(StringPool.CLOSE_CURLY_BRACE);
1213
1214            throw new NoSuchEmailAddressException(msg.toString());
1215        }
1216        else {
1217            return (EmailAddress)list.get(0);
1218        }
1219    }
1220
1221    public EmailAddress[] findByC_C_C_PrevAndNext(long emailAddressId,
1222        long companyId, long classNameId, long classPK, OrderByComparator obc)
1223        throws NoSuchEmailAddressException, SystemException {
1224        EmailAddress emailAddress = findByPrimaryKey(emailAddressId);
1225
1226        int count = countByC_C_C(companyId, classNameId, classPK);
1227
1228        Session session = null;
1229
1230        try {
1231            session = openSession();
1232
1233            StringMaker query = new StringMaker();
1234
1235            query.append("FROM com.liferay.portal.model.EmailAddress WHERE ");
1236
1237            query.append("companyId = ?");
1238
1239            query.append(" AND ");
1240
1241            query.append("classNameId = ?");
1242
1243            query.append(" AND ");
1244
1245            query.append("classPK = ?");
1246
1247            query.append(" ");
1248
1249            if (obc != null) {
1250                query.append("ORDER BY ");
1251                query.append(obc.getOrderBy());
1252            }
1253
1254            else {
1255                query.append("ORDER BY ");
1256
1257                query.append("createDate ASC");
1258            }
1259
1260            Query q = session.createQuery(query.toString());
1261
1262            int queryPos = 0;
1263
1264            q.setLong(queryPos++, companyId);
1265
1266            q.setLong(queryPos++, classNameId);
1267
1268            q.setLong(queryPos++, classPK);
1269
1270            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1271                    emailAddress);
1272
1273            EmailAddress[] array = new EmailAddressImpl[3];
1274
1275            array[0] = (EmailAddress)objArray[0];
1276            array[1] = (EmailAddress)objArray[1];
1277            array[2] = (EmailAddress)objArray[2];
1278
1279            return array;
1280        }
1281        catch (Exception e) {
1282            throw HibernateUtil.processException(e);
1283        }
1284        finally {
1285            closeSession(session);
1286        }
1287    }
1288
1289    public List findByC_C_C_P(long companyId, long classNameId, long classPK,
1290        boolean primary) throws SystemException {
1291        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
1292        String finderClassName = EmailAddress.class.getName();
1293        String finderMethodName = "findByC_C_C_P";
1294        String[] finderParams = new String[] {
1295                Long.class.getName(), Long.class.getName(), Long.class.getName(),
1296                Boolean.class.getName()
1297            };
1298        Object[] finderArgs = new Object[] {
1299                new Long(companyId), new Long(classNameId), new Long(classPK),
1300                Boolean.valueOf(primary)
1301            };
1302
1303        Object result = null;
1304
1305        if (finderClassNameCacheEnabled) {
1306            result = FinderCache.getResult(finderClassName, finderMethodName,
1307                    finderParams, finderArgs, getSessionFactory());
1308        }
1309
1310        if (result == null) {
1311            Session session = null;
1312
1313            try {
1314                session = openSession();
1315
1316                StringMaker query = new StringMaker();
1317
1318                query.append(
1319                    "FROM com.liferay.portal.model.EmailAddress WHERE ");
1320
1321                query.append("companyId = ?");
1322
1323                query.append(" AND ");
1324
1325                query.append("classNameId = ?");
1326
1327                query.append(" AND ");
1328
1329                query.append("classPK = ?");
1330
1331                query.append(" AND ");
1332
1333                query.append("primary_ = ?");
1334
1335                query.append(" ");
1336
1337                query.append("ORDER BY ");
1338
1339                query.append("createDate ASC");
1340
1341                Query q = session.createQuery(query.toString());
1342
1343                int queryPos = 0;
1344
1345                q.setLong(queryPos++, companyId);
1346
1347                q.setLong(queryPos++, classNameId);
1348
1349                q.setLong(queryPos++, classPK);
1350
1351                q.setBoolean(queryPos++, primary);
1352
1353                List list = q.list();
1354
1355                FinderCache.putResult(finderClassNameCacheEnabled,
1356                    finderClassName, finderMethodName, finderParams,
1357                    finderArgs, list);
1358
1359                return list;
1360            }
1361            catch (Exception e) {
1362                throw HibernateUtil.processException(e);
1363            }
1364            finally {
1365                closeSession(session);
1366            }
1367        }
1368        else {
1369            return (List)result;
1370        }
1371    }
1372
1373    public List findByC_C_C_P(long companyId, long classNameId, long classPK,
1374        boolean primary, int begin, int end) throws SystemException {
1375        return findByC_C_C_P(companyId, classNameId, classPK, primary, begin,
1376            end, null);
1377    }
1378
1379    public List findByC_C_C_P(long companyId, long classNameId, long classPK,
1380        boolean primary, int begin, int end, OrderByComparator obc)
1381        throws SystemException {
1382        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
1383        String finderClassName = EmailAddress.class.getName();
1384        String finderMethodName = "findByC_C_C_P";
1385        String[] finderParams = new String[] {
1386                Long.class.getName(), Long.class.getName(), Long.class.getName(),
1387                Boolean.class.getName(),
1388                
1389                "java.lang.Integer", "java.lang.Integer",
1390                "com.liferay.portal.kernel.util.OrderByComparator"
1391            };
1392        Object[] finderArgs = new Object[] {
1393                new Long(companyId), new Long(classNameId), new Long(classPK),
1394                Boolean.valueOf(primary),
1395                
1396                String.valueOf(begin), String.valueOf(end), String.valueOf(obc)
1397            };
1398
1399        Object result = null;
1400
1401        if (finderClassNameCacheEnabled) {
1402            result = FinderCache.getResult(finderClassName, finderMethodName,
1403                    finderParams, finderArgs, getSessionFactory());
1404        }
1405
1406        if (result == null) {
1407            Session session = null;
1408
1409            try {
1410                session = openSession();
1411
1412                StringMaker query = new StringMaker();
1413
1414                query.append(
1415                    "FROM com.liferay.portal.model.EmailAddress WHERE ");
1416
1417                query.append("companyId = ?");
1418
1419                query.append(" AND ");
1420
1421                query.append("classNameId = ?");
1422
1423                query.append(" AND ");
1424
1425                query.append("classPK = ?");
1426
1427                query.append(" AND ");
1428
1429                query.append("primary_ = ?");
1430
1431                query.append(" ");
1432
1433                if (obc != null) {
1434                    query.append("ORDER BY ");
1435                    query.append(obc.getOrderBy());
1436                }
1437
1438                else {
1439                    query.append("ORDER BY ");
1440
1441                    query.append("createDate ASC");
1442                }
1443
1444                Query q = session.createQuery(query.toString());
1445
1446                int queryPos = 0;
1447
1448                q.setLong(queryPos++, companyId);
1449
1450                q.setLong(queryPos++, classNameId);
1451
1452                q.setLong(queryPos++, classPK);
1453
1454                q.setBoolean(queryPos++, primary);
1455
1456                List list = QueryUtil.list(q, getDialect(), begin, end);
1457
1458                FinderCache.putResult(finderClassNameCacheEnabled,
1459                    finderClassName, finderMethodName, finderParams,
1460                    finderArgs, list);
1461
1462                return list;
1463            }
1464            catch (Exception e) {
1465                throw HibernateUtil.processException(e);
1466            }
1467            finally {
1468                closeSession(session);
1469            }
1470        }
1471        else {
1472            return (List)result;
1473        }
1474    }
1475
1476    public EmailAddress findByC_C_C_P_First(long companyId, long classNameId,
1477        long classPK, boolean primary, OrderByComparator obc)
1478        throws NoSuchEmailAddressException, SystemException {
1479        List list = findByC_C_C_P(companyId, classNameId, classPK, primary, 0,
1480                1, obc);
1481
1482        if (list.size() == 0) {
1483            StringMaker msg = new StringMaker();
1484
1485            msg.append("No EmailAddress exists with the key {");
1486
1487            msg.append("companyId=" + companyId);
1488
1489            msg.append(", ");
1490            msg.append("classNameId=" + classNameId);
1491
1492            msg.append(", ");
1493            msg.append("classPK=" + classPK);
1494
1495            msg.append(", ");
1496            msg.append("primary=" + primary);
1497
1498            msg.append(StringPool.CLOSE_CURLY_BRACE);
1499
1500            throw new NoSuchEmailAddressException(msg.toString());
1501        }
1502        else {
1503            return (EmailAddress)list.get(0);
1504        }
1505    }
1506
1507    public EmailAddress findByC_C_C_P_Last(long companyId, long classNameId,
1508        long classPK, boolean primary, OrderByComparator obc)
1509        throws NoSuchEmailAddressException, SystemException {
1510        int count = countByC_C_C_P(companyId, classNameId, classPK, primary);
1511
1512        List list = findByC_C_C_P(companyId, classNameId, classPK, primary,
1513                count - 1, count, obc);
1514
1515        if (list.size() == 0) {
1516            StringMaker msg = new StringMaker();
1517
1518            msg.append("No EmailAddress exists with the key {");
1519
1520            msg.append("companyId=" + companyId);
1521
1522            msg.append(", ");
1523            msg.append("classNameId=" + classNameId);
1524
1525            msg.append(", ");
1526            msg.append("classPK=" + classPK);
1527
1528            msg.append(", ");
1529            msg.append("primary=" + primary);
1530
1531            msg.append(StringPool.CLOSE_CURLY_BRACE);
1532
1533            throw new NoSuchEmailAddressException(msg.toString());
1534        }
1535        else {
1536            return (EmailAddress)list.get(0);
1537        }
1538    }
1539
1540    public EmailAddress[] findByC_C_C_P_PrevAndNext(long emailAddressId,
1541        long companyId, long classNameId, long classPK, boolean primary,
1542        OrderByComparator obc)
1543        throws NoSuchEmailAddressException, SystemException {
1544        EmailAddress emailAddress = findByPrimaryKey(emailAddressId);
1545
1546        int count = countByC_C_C_P(companyId, classNameId, classPK, primary);
1547
1548        Session session = null;
1549
1550        try {
1551            session = openSession();
1552
1553            StringMaker query = new StringMaker();
1554
1555            query.append("FROM com.liferay.portal.model.EmailAddress WHERE ");
1556
1557            query.append("companyId = ?");
1558
1559            query.append(" AND ");
1560
1561            query.append("classNameId = ?");
1562
1563            query.append(" AND ");
1564
1565            query.append("classPK = ?");
1566
1567            query.append(" AND ");
1568
1569            query.append("primary_ = ?");
1570
1571            query.append(" ");
1572
1573            if (obc != null) {
1574                query.append("ORDER BY ");
1575                query.append(obc.getOrderBy());
1576            }
1577
1578            else {
1579                query.append("ORDER BY ");
1580
1581                query.append("createDate ASC");
1582            }
1583
1584            Query q = session.createQuery(query.toString());
1585
1586            int queryPos = 0;
1587
1588            q.setLong(queryPos++, companyId);
1589
1590            q.setLong(queryPos++, classNameId);
1591
1592            q.setLong(queryPos++, classPK);
1593
1594            q.setBoolean(queryPos++, primary);
1595
1596            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1597                    emailAddress);
1598
1599            EmailAddress[] array = new EmailAddressImpl[3];
1600
1601            array[0] = (EmailAddress)objArray[0];
1602            array[1] = (EmailAddress)objArray[1];
1603            array[2] = (EmailAddress)objArray[2];
1604
1605            return array;
1606        }
1607        catch (Exception e) {
1608            throw HibernateUtil.processException(e);
1609        }
1610        finally {
1611            closeSession(session);
1612        }
1613    }
1614
1615    public List findWithDynamicQuery(DynamicQueryInitializer queryInitializer)
1616        throws SystemException {
1617        Session session = null;
1618
1619        try {
1620            session = openSession();
1621
1622            DynamicQuery query = queryInitializer.initialize(session);
1623
1624            return query.list();
1625        }
1626        catch (Exception e) {
1627            throw HibernateUtil.processException(e);
1628        }
1629        finally {
1630            closeSession(session);
1631        }
1632    }
1633
1634    public List findWithDynamicQuery(DynamicQueryInitializer queryInitializer,
1635        int begin, int end) throws SystemException {
1636        Session session = null;
1637
1638        try {
1639            session = openSession();
1640
1641            DynamicQuery query = queryInitializer.initialize(session);
1642
1643            query.setLimit(begin, end);
1644
1645            return query.list();
1646        }
1647        catch (Exception e) {
1648            throw HibernateUtil.processException(e);
1649        }
1650        finally {
1651            closeSession(session);
1652        }
1653    }
1654
1655    public List findAll() throws SystemException {
1656        return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1657    }
1658
1659    public List findAll(int begin, int end) throws SystemException {
1660        return findAll(begin, end, null);
1661    }
1662
1663    public List findAll(int begin, int end, OrderByComparator obc)
1664        throws SystemException {
1665        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
1666        String finderClassName = EmailAddress.class.getName();
1667        String finderMethodName = "findAll";
1668        String[] finderParams = new String[] {
1669                "java.lang.Integer", "java.lang.Integer",
1670                "com.liferay.portal.kernel.util.OrderByComparator"
1671            };
1672        Object[] finderArgs = new Object[] {
1673                String.valueOf(begin), String.valueOf(end), String.valueOf(obc)
1674            };
1675
1676        Object result = null;
1677
1678        if (finderClassNameCacheEnabled) {
1679            result = FinderCache.getResult(finderClassName, finderMethodName,
1680                    finderParams, finderArgs, getSessionFactory());
1681        }
1682
1683        if (result == null) {
1684            Session session = null;
1685
1686            try {
1687                session = openSession();
1688
1689                StringMaker query = new StringMaker();
1690
1691                query.append("FROM com.liferay.portal.model.EmailAddress ");
1692
1693                if (obc != null) {
1694                    query.append("ORDER BY ");
1695                    query.append(obc.getOrderBy());
1696                }
1697
1698                else {
1699                    query.append("ORDER BY ");
1700
1701                    query.append("createDate ASC");
1702                }
1703
1704                Query q = session.createQuery(query.toString());
1705
1706                List list = QueryUtil.list(q, getDialect(), begin, end);
1707
1708                if (obc == null) {
1709                    Collections.sort(list);
1710                }
1711
1712                FinderCache.putResult(finderClassNameCacheEnabled,
1713                    finderClassName, finderMethodName, finderParams,
1714                    finderArgs, list);
1715
1716                return list;
1717            }
1718            catch (Exception e) {
1719                throw HibernateUtil.processException(e);
1720            }
1721            finally {
1722                closeSession(session);
1723            }
1724        }
1725        else {
1726            return (List)result;
1727        }
1728    }
1729
1730    public void removeByCompanyId(long companyId) throws SystemException {
1731        Iterator itr = findByCompanyId(companyId).iterator();
1732
1733        while (itr.hasNext()) {
1734            EmailAddress emailAddress = (EmailAddress)itr.next();
1735
1736            remove(emailAddress);
1737        }
1738    }
1739
1740    public void removeByUserId(long userId) throws SystemException {
1741        Iterator itr = findByUserId(userId).iterator();
1742
1743        while (itr.hasNext()) {
1744            EmailAddress emailAddress = (EmailAddress)itr.next();
1745
1746            remove(emailAddress);
1747        }
1748    }
1749
1750    public void removeByC_C(long companyId, long classNameId)
1751        throws SystemException {
1752        Iterator itr = findByC_C(companyId, classNameId).iterator();
1753
1754        while (itr.hasNext()) {
1755            EmailAddress emailAddress = (EmailAddress)itr.next();
1756
1757            remove(emailAddress);
1758        }
1759    }
1760
1761    public void removeByC_C_C(long companyId, long classNameId, long classPK)
1762        throws SystemException {
1763        Iterator itr = findByC_C_C(companyId, classNameId, classPK).iterator();
1764
1765        while (itr.hasNext()) {
1766            EmailAddress emailAddress = (EmailAddress)itr.next();
1767
1768            remove(emailAddress);
1769        }
1770    }
1771
1772    public void removeByC_C_C_P(long companyId, long classNameId, long classPK,
1773        boolean primary) throws SystemException {
1774        Iterator itr = findByC_C_C_P(companyId, classNameId, classPK, primary)
1775                           .iterator();
1776
1777        while (itr.hasNext()) {
1778            EmailAddress emailAddress = (EmailAddress)itr.next();
1779
1780            remove(emailAddress);
1781        }
1782    }
1783
1784    public void removeAll() throws SystemException {
1785        Iterator itr = findAll().iterator();
1786
1787        while (itr.hasNext()) {
1788            remove((EmailAddress)itr.next());
1789        }
1790    }
1791
1792    public int countByCompanyId(long companyId) throws SystemException {
1793        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
1794        String finderClassName = EmailAddress.class.getName();
1795        String finderMethodName = "countByCompanyId";
1796        String[] finderParams = new String[] { Long.class.getName() };
1797        Object[] finderArgs = new Object[] { new Long(companyId) };
1798
1799        Object result = null;
1800
1801        if (finderClassNameCacheEnabled) {
1802            result = FinderCache.getResult(finderClassName, finderMethodName,
1803                    finderParams, finderArgs, getSessionFactory());
1804        }
1805
1806        if (result == null) {
1807            Session session = null;
1808
1809            try {
1810                session = openSession();
1811
1812                StringMaker query = new StringMaker();
1813
1814                query.append("SELECT COUNT(*) ");
1815                query.append(
1816                    "FROM com.liferay.portal.model.EmailAddress WHERE ");
1817
1818                query.append("companyId = ?");
1819
1820                query.append(" ");
1821
1822                Query q = session.createQuery(query.toString());
1823
1824                int queryPos = 0;
1825
1826                q.setLong(queryPos++, companyId);
1827
1828                Long count = null;
1829
1830                Iterator itr = q.list().iterator();
1831
1832                if (itr.hasNext()) {
1833                    count = (Long)itr.next();
1834                }
1835
1836                if (count == null) {
1837                    count = new Long(0);
1838                }
1839
1840                FinderCache.putResult(finderClassNameCacheEnabled,
1841                    finderClassName, finderMethodName, finderParams,
1842                    finderArgs, count);
1843
1844                return count.intValue();
1845            }
1846            catch (Exception e) {
1847                throw HibernateUtil.processException(e);
1848            }
1849            finally {
1850                closeSession(session);
1851            }
1852        }
1853        else {
1854            return ((Long)result).intValue();
1855        }
1856    }
1857
1858    public int countByUserId(long userId) throws SystemException {
1859        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
1860        String finderClassName = EmailAddress.class.getName();
1861        String finderMethodName = "countByUserId";
1862        String[] finderParams = new String[] { Long.class.getName() };
1863        Object[] finderArgs = new Object[] { new Long(userId) };
1864
1865        Object result = null;
1866
1867        if (finderClassNameCacheEnabled) {
1868            result = FinderCache.getResult(finderClassName, finderMethodName,
1869                    finderParams, finderArgs, getSessionFactory());
1870        }
1871
1872        if (result == null) {
1873            Session session = null;
1874
1875            try {
1876                session = openSession();
1877
1878                StringMaker query = new StringMaker();
1879
1880                query.append("SELECT COUNT(*) ");
1881                query.append(
1882                    "FROM com.liferay.portal.model.EmailAddress WHERE ");
1883
1884                query.append("userId = ?");
1885
1886                query.append(" ");
1887
1888                Query q = session.createQuery(query.toString());
1889
1890                int queryPos = 0;
1891
1892                q.setLong(queryPos++, userId);
1893
1894                Long count = null;
1895
1896                Iterator itr = q.list().iterator();
1897
1898                if (itr.hasNext()) {
1899                    count = (Long)itr.next();
1900                }
1901
1902                if (count == null) {
1903                    count = new Long(0);
1904                }
1905
1906                FinderCache.putResult(finderClassNameCacheEnabled,
1907                    finderClassName, finderMethodName, finderParams,
1908                    finderArgs, count);
1909
1910                return count.intValue();
1911            }
1912            catch (Exception e) {
1913                throw HibernateUtil.processException(e);
1914            }
1915            finally {
1916                closeSession(session);
1917            }
1918        }
1919        else {
1920            return ((Long)result).intValue();
1921        }
1922    }
1923
1924    public int countByC_C(long companyId, long classNameId)
1925        throws SystemException {
1926        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
1927        String finderClassName = EmailAddress.class.getName();
1928        String finderMethodName = "countByC_C";
1929        String[] finderParams = new String[] {
1930                Long.class.getName(), Long.class.getName()
1931            };
1932        Object[] finderArgs = new Object[] {
1933                new Long(companyId), new Long(classNameId)
1934            };
1935
1936        Object result = null;
1937
1938        if (finderClassNameCacheEnabled) {
1939            result = FinderCache.getResult(finderClassName, finderMethodName,
1940                    finderParams, finderArgs, getSessionFactory());
1941        }
1942
1943        if (result == null) {
1944            Session session = null;
1945
1946            try {
1947                session = openSession();
1948
1949                StringMaker query = new StringMaker();
1950
1951                query.append("SELECT COUNT(*) ");
1952                query.append(
1953                    "FROM com.liferay.portal.model.EmailAddress WHERE ");
1954
1955                query.append("companyId = ?");
1956
1957                query.append(" AND ");
1958
1959                query.append("classNameId = ?");
1960
1961                query.append(" ");
1962
1963                Query q = session.createQuery(query.toString());
1964
1965                int queryPos = 0;
1966
1967                q.setLong(queryPos++, companyId);
1968
1969                q.setLong(queryPos++, classNameId);
1970
1971                Long count = null;
1972
1973                Iterator itr = q.list().iterator();
1974
1975                if (itr.hasNext()) {
1976                    count = (Long)itr.next();
1977                }
1978
1979                if (count == null) {
1980                    count = new Long(0);
1981                }
1982
1983                FinderCache.putResult(finderClassNameCacheEnabled,
1984                    finderClassName, finderMethodName, finderParams,
1985                    finderArgs, count);
1986
1987                return count.intValue();
1988            }
1989            catch (Exception e) {
1990                throw HibernateUtil.processException(e);
1991            }
1992            finally {
1993                closeSession(session);
1994            }
1995        }
1996        else {
1997            return ((Long)result).intValue();
1998        }
1999    }
2000
2001    public int countByC_C_C(long companyId, long classNameId, long classPK)
2002        throws SystemException {
2003        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
2004        String finderClassName = EmailAddress.class.getName();
2005        String finderMethodName = "countByC_C_C";
2006        String[] finderParams = new String[] {
2007                Long.class.getName(), Long.class.getName(), Long.class.getName()
2008            };
2009        Object[] finderArgs = new Object[] {
2010                new Long(companyId), new Long(classNameId), new Long(classPK)
2011            };
2012
2013        Object result = null;
2014
2015        if (finderClassNameCacheEnabled) {
2016            result = FinderCache.getResult(finderClassName, finderMethodName,
2017                    finderParams, finderArgs, getSessionFactory());
2018        }
2019
2020        if (result == null) {
2021            Session session = null;
2022
2023            try {
2024                session = openSession();
2025
2026                StringMaker query = new StringMaker();
2027
2028                query.append("SELECT COUNT(*) ");
2029                query.append(
2030                    "FROM com.liferay.portal.model.EmailAddress WHERE ");
2031
2032                query.append("companyId = ?");
2033
2034                query.append(" AND ");
2035
2036                query.append("classNameId = ?");
2037
2038                query.append(" AND ");
2039
2040                query.append("classPK = ?");
2041
2042                query.append(" ");
2043
2044                Query q = session.createQuery(query.toString());
2045
2046                int queryPos = 0;
2047
2048                q.setLong(queryPos++, companyId);
2049
2050                q.setLong(queryPos++, classNameId);
2051
2052                q.setLong(queryPos++, classPK);
2053
2054                Long count = null;
2055
2056                Iterator itr = q.list().iterator();
2057
2058                if (itr.hasNext()) {
2059                    count = (Long)itr.next();
2060                }
2061
2062                if (count == null) {
2063                    count = new Long(0);
2064                }
2065
2066                FinderCache.putResult(finderClassNameCacheEnabled,
2067                    finderClassName, finderMethodName, finderParams,
2068                    finderArgs, count);
2069
2070                return count.intValue();
2071            }
2072            catch (Exception e) {
2073                throw HibernateUtil.processException(e);
2074            }
2075            finally {
2076                closeSession(session);
2077            }
2078        }
2079        else {
2080            return ((Long)result).intValue();
2081        }
2082    }
2083
2084    public int countByC_C_C_P(long companyId, long classNameId, long classPK,
2085        boolean primary) throws SystemException {
2086        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
2087        String finderClassName = EmailAddress.class.getName();
2088        String finderMethodName = "countByC_C_C_P";
2089        String[] finderParams = new String[] {
2090                Long.class.getName(), Long.class.getName(), Long.class.getName(),
2091                Boolean.class.getName()
2092            };
2093        Object[] finderArgs = new Object[] {
2094                new Long(companyId), new Long(classNameId), new Long(classPK),
2095                Boolean.valueOf(primary)
2096            };
2097
2098        Object result = null;
2099
2100        if (finderClassNameCacheEnabled) {
2101            result = FinderCache.getResult(finderClassName, finderMethodName,
2102                    finderParams, finderArgs, getSessionFactory());
2103        }
2104
2105        if (result == null) {
2106            Session session = null;
2107
2108            try {
2109                session = openSession();
2110
2111                StringMaker query = new StringMaker();
2112
2113                query.append("SELECT COUNT(*) ");
2114                query.append(
2115                    "FROM com.liferay.portal.model.EmailAddress WHERE ");
2116
2117                query.append("companyId = ?");
2118
2119                query.append(" AND ");
2120
2121                query.append("classNameId = ?");
2122
2123                query.append(" AND ");
2124
2125                query.append("classPK = ?");
2126
2127                query.append(" AND ");
2128
2129                query.append("primary_ = ?");
2130
2131                query.append(" ");
2132
2133                Query q = session.createQuery(query.toString());
2134
2135                int queryPos = 0;
2136
2137                q.setLong(queryPos++, companyId);
2138
2139                q.setLong(queryPos++, classNameId);
2140
2141                q.setLong(queryPos++, classPK);
2142
2143                q.setBoolean(queryPos++, primary);
2144
2145                Long count = null;
2146
2147                Iterator itr = q.list().iterator();
2148
2149                if (itr.hasNext()) {
2150                    count = (Long)itr.next();
2151                }
2152
2153                if (count == null) {
2154                    count = new Long(0);
2155                }
2156
2157                FinderCache.putResult(finderClassNameCacheEnabled,
2158                    finderClassName, finderMethodName, finderParams,
2159                    finderArgs, count);
2160
2161                return count.intValue();
2162            }
2163            catch (Exception e) {
2164                throw HibernateUtil.processException(e);
2165            }
2166            finally {
2167                closeSession(session);
2168            }
2169        }
2170        else {
2171            return ((Long)result).intValue();
2172        }
2173    }
2174
2175    public int countAll() throws SystemException {
2176        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
2177        String finderClassName = EmailAddress.class.getName();
2178        String finderMethodName = "countAll";
2179        String[] finderParams = new String[] {  };
2180        Object[] finderArgs = new Object[] {  };
2181
2182        Object result = null;
2183
2184        if (finderClassNameCacheEnabled) {
2185            result = FinderCache.getResult(finderClassName, finderMethodName,
2186                    finderParams, finderArgs, getSessionFactory());
2187        }
2188
2189        if (result == null) {
2190            Session session = null;
2191
2192            try {
2193                session = openSession();
2194
2195                Query q = session.createQuery(
2196                        "SELECT COUNT(*) FROM com.liferay.portal.model.EmailAddress");
2197
2198                Long count = null;
2199
2200                Iterator itr = q.list().iterator();
2201
2202                if (itr.hasNext()) {
2203                    count = (Long)itr.next();
2204                }
2205
2206                if (count == null) {
2207                    count = new Long(0);
2208                }
2209
2210                FinderCache.putResult(finderClassNameCacheEnabled,
2211                    finderClassName, finderMethodName, finderParams,
2212                    finderArgs, count);
2213
2214                return count.intValue();
2215            }
2216            catch (Exception e) {
2217                throw HibernateUtil.processException(e);
2218            }
2219            finally {
2220                closeSession(session);
2221            }
2222        }
2223        else {
2224            return ((Long)result).intValue();
2225        }
2226    }
2227
2228    protected void initDao() {
2229    }
2230
2231    private static ModelListener _getListener() {
2232        if (Validator.isNotNull(_LISTENER)) {
2233            try {
2234                return (ModelListener)Class.forName(_LISTENER).newInstance();
2235            }
2236            catch (Exception e) {
2237                _log.error(e);
2238            }
2239        }
2240
2241        return null;
2242    }
2243
2244    private static final String _LISTENER = GetterUtil.getString(PropsUtil.get(
2245                "value.object.listener.com.liferay.portal.model.EmailAddress"));
2246    private static Log _log = LogFactory.getLog(EmailAddressPersistenceImpl.class);
2247}