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