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.portlet.bookmarks.service.persistence;
24  
25  import com.liferay.portal.SystemException;
26  import com.liferay.portal.kernel.dao.orm.DynamicQuery;
27  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
28  import com.liferay.portal.kernel.dao.orm.Query;
29  import com.liferay.portal.kernel.dao.orm.QueryPos;
30  import com.liferay.portal.kernel.dao.orm.QueryUtil;
31  import com.liferay.portal.kernel.dao.orm.Session;
32  import com.liferay.portal.kernel.util.GetterUtil;
33  import com.liferay.portal.kernel.util.ListUtil;
34  import com.liferay.portal.kernel.util.OrderByComparator;
35  import com.liferay.portal.kernel.util.StringPool;
36  import com.liferay.portal.kernel.util.StringUtil;
37  import com.liferay.portal.kernel.util.Validator;
38  import com.liferay.portal.kernel.uuid.PortalUUIDUtil;
39  import com.liferay.portal.model.ModelListener;
40  import com.liferay.portal.service.persistence.BatchSessionUtil;
41  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
42  
43  import com.liferay.portlet.bookmarks.NoSuchEntryException;
44  import com.liferay.portlet.bookmarks.model.BookmarksEntry;
45  import com.liferay.portlet.bookmarks.model.impl.BookmarksEntryImpl;
46  import com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl;
47  
48  import org.apache.commons.logging.Log;
49  import org.apache.commons.logging.LogFactory;
50  
51  import java.util.ArrayList;
52  import java.util.Collections;
53  import java.util.Iterator;
54  import java.util.List;
55  
56  /**
57   * <a href="BookmarksEntryPersistenceImpl.java.html"><b><i>View Source</i></b></a>
58   *
59   * @author Brian Wing Shun Chan
60   *
61   */
62  public class BookmarksEntryPersistenceImpl extends BasePersistenceImpl
63      implements BookmarksEntryPersistence {
64      public BookmarksEntry create(long entryId) {
65          BookmarksEntry bookmarksEntry = new BookmarksEntryImpl();
66  
67          bookmarksEntry.setNew(true);
68          bookmarksEntry.setPrimaryKey(entryId);
69  
70          String uuid = PortalUUIDUtil.generate();
71  
72          bookmarksEntry.setUuid(uuid);
73  
74          return bookmarksEntry;
75      }
76  
77      public BookmarksEntry remove(long entryId)
78          throws NoSuchEntryException, SystemException {
79          Session session = null;
80  
81          try {
82              session = openSession();
83  
84              BookmarksEntry bookmarksEntry = (BookmarksEntry)session.get(BookmarksEntryImpl.class,
85                      new Long(entryId));
86  
87              if (bookmarksEntry == null) {
88                  if (_log.isWarnEnabled()) {
89                      _log.warn("No BookmarksEntry exists with the primary key " +
90                          entryId);
91                  }
92  
93                  throw new NoSuchEntryException(
94                      "No BookmarksEntry exists with the primary key " + entryId);
95              }
96  
97              return remove(bookmarksEntry);
98          }
99          catch (NoSuchEntryException nsee) {
100             throw nsee;
101         }
102         catch (Exception e) {
103             throw processException(e);
104         }
105         finally {
106             closeSession(session);
107         }
108     }
109 
110     public BookmarksEntry remove(BookmarksEntry bookmarksEntry)
111         throws SystemException {
112         if (_listeners.length > 0) {
113             for (ModelListener listener : _listeners) {
114                 listener.onBeforeRemove(bookmarksEntry);
115             }
116         }
117 
118         bookmarksEntry = removeImpl(bookmarksEntry);
119 
120         if (_listeners.length > 0) {
121             for (ModelListener listener : _listeners) {
122                 listener.onAfterRemove(bookmarksEntry);
123             }
124         }
125 
126         return bookmarksEntry;
127     }
128 
129     protected BookmarksEntry removeImpl(BookmarksEntry bookmarksEntry)
130         throws SystemException {
131         Session session = null;
132 
133         try {
134             session = openSession();
135 
136             if (BatchSessionUtil.isEnabled()) {
137                 Object staleObject = session.get(BookmarksEntryImpl.class,
138                         bookmarksEntry.getPrimaryKeyObj());
139 
140                 if (staleObject != null) {
141                     session.evict(staleObject);
142                 }
143             }
144 
145             session.delete(bookmarksEntry);
146 
147             session.flush();
148 
149             return bookmarksEntry;
150         }
151         catch (Exception e) {
152             throw processException(e);
153         }
154         finally {
155             closeSession(session);
156 
157             FinderCacheUtil.clearCache(BookmarksEntry.class.getName());
158         }
159     }
160 
161     /**
162      * @deprecated Use <code>update(BookmarksEntry bookmarksEntry, boolean merge)</code>.
163      */
164     public BookmarksEntry update(BookmarksEntry bookmarksEntry)
165         throws SystemException {
166         if (_log.isWarnEnabled()) {
167             _log.warn(
168                 "Using the deprecated update(BookmarksEntry bookmarksEntry) method. Use update(BookmarksEntry bookmarksEntry, boolean merge) instead.");
169         }
170 
171         return update(bookmarksEntry, false);
172     }
173 
174     /**
175      * Add, update, or merge, the entity. This method also calls the model
176      * listeners to trigger the proper events associated with adding, deleting,
177      * or updating an entity.
178      *
179      * @param        bookmarksEntry the entity to add, update, or merge
180      * @param        merge boolean value for whether to merge the entity. The
181      *                default value is false. Setting merge to true is more
182      *                expensive and should only be true when bookmarksEntry is
183      *                transient. See LEP-5473 for a detailed discussion of this
184      *                method.
185      * @return        true if the portlet can be displayed via Ajax
186      */
187     public BookmarksEntry update(BookmarksEntry bookmarksEntry, boolean merge)
188         throws SystemException {
189         boolean isNew = bookmarksEntry.isNew();
190 
191         if (_listeners.length > 0) {
192             for (ModelListener listener : _listeners) {
193                 if (isNew) {
194                     listener.onBeforeCreate(bookmarksEntry);
195                 }
196                 else {
197                     listener.onBeforeUpdate(bookmarksEntry);
198                 }
199             }
200         }
201 
202         bookmarksEntry = updateImpl(bookmarksEntry, merge);
203 
204         if (_listeners.length > 0) {
205             for (ModelListener listener : _listeners) {
206                 if (isNew) {
207                     listener.onAfterCreate(bookmarksEntry);
208                 }
209                 else {
210                     listener.onAfterUpdate(bookmarksEntry);
211                 }
212             }
213         }
214 
215         return bookmarksEntry;
216     }
217 
218     public BookmarksEntry updateImpl(
219         com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry,
220         boolean merge) throws SystemException {
221         if (Validator.isNull(bookmarksEntry.getUuid())) {
222             String uuid = PortalUUIDUtil.generate();
223 
224             bookmarksEntry.setUuid(uuid);
225         }
226 
227         Session session = null;
228 
229         try {
230             session = openSession();
231 
232             BatchSessionUtil.update(session, bookmarksEntry, merge);
233 
234             bookmarksEntry.setNew(false);
235 
236             return bookmarksEntry;
237         }
238         catch (Exception e) {
239             throw processException(e);
240         }
241         finally {
242             closeSession(session);
243 
244             FinderCacheUtil.clearCache(BookmarksEntry.class.getName());
245         }
246     }
247 
248     public BookmarksEntry findByPrimaryKey(long entryId)
249         throws NoSuchEntryException, SystemException {
250         BookmarksEntry bookmarksEntry = fetchByPrimaryKey(entryId);
251 
252         if (bookmarksEntry == null) {
253             if (_log.isWarnEnabled()) {
254                 _log.warn("No BookmarksEntry exists with the primary key " +
255                     entryId);
256             }
257 
258             throw new NoSuchEntryException(
259                 "No BookmarksEntry exists with the primary key " + entryId);
260         }
261 
262         return bookmarksEntry;
263     }
264 
265     public BookmarksEntry fetchByPrimaryKey(long entryId)
266         throws SystemException {
267         Session session = null;
268 
269         try {
270             session = openSession();
271 
272             return (BookmarksEntry)session.get(BookmarksEntryImpl.class,
273                 new Long(entryId));
274         }
275         catch (Exception e) {
276             throw processException(e);
277         }
278         finally {
279             closeSession(session);
280         }
281     }
282 
283     public List<BookmarksEntry> findByUuid(String uuid)
284         throws SystemException {
285         boolean finderClassNameCacheEnabled = BookmarksEntryModelImpl.CACHE_ENABLED;
286         String finderClassName = BookmarksEntry.class.getName();
287         String finderMethodName = "findByUuid";
288         String[] finderParams = new String[] { String.class.getName() };
289         Object[] finderArgs = new Object[] { uuid };
290 
291         Object result = null;
292 
293         if (finderClassNameCacheEnabled) {
294             result = FinderCacheUtil.getResult(finderClassName,
295                     finderMethodName, finderParams, finderArgs, this);
296         }
297 
298         if (result == null) {
299             Session session = null;
300 
301             try {
302                 session = openSession();
303 
304                 StringBuilder query = new StringBuilder();
305 
306                 query.append(
307                     "FROM com.liferay.portlet.bookmarks.model.BookmarksEntry WHERE ");
308 
309                 if (uuid == null) {
310                     query.append("uuid_ IS NULL");
311                 }
312                 else {
313                     query.append("uuid_ = ?");
314                 }
315 
316                 query.append(" ");
317 
318                 query.append("ORDER BY ");
319 
320                 query.append("folderId ASC, ");
321                 query.append("name ASC");
322 
323                 Query q = session.createQuery(query.toString());
324 
325                 QueryPos qPos = QueryPos.getInstance(q);
326 
327                 if (uuid != null) {
328                     qPos.add(uuid);
329                 }
330 
331                 List<BookmarksEntry> list = q.list();
332 
333                 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
334                     finderClassName, finderMethodName, finderParams,
335                     finderArgs, list);
336 
337                 return list;
338             }
339             catch (Exception e) {
340                 throw processException(e);
341             }
342             finally {
343                 closeSession(session);
344             }
345         }
346         else {
347             return (List<BookmarksEntry>)result;
348         }
349     }
350 
351     public List<BookmarksEntry> findByUuid(String uuid, int start, int end)
352         throws SystemException {
353         return findByUuid(uuid, start, end, null);
354     }
355 
356     public List<BookmarksEntry> findByUuid(String uuid, int start, int end,
357         OrderByComparator obc) throws SystemException {
358         boolean finderClassNameCacheEnabled = BookmarksEntryModelImpl.CACHE_ENABLED;
359         String finderClassName = BookmarksEntry.class.getName();
360         String finderMethodName = "findByUuid";
361         String[] finderParams = new String[] {
362                 String.class.getName(),
363                 
364                 "java.lang.Integer", "java.lang.Integer",
365                 "com.liferay.portal.kernel.util.OrderByComparator"
366             };
367         Object[] finderArgs = new Object[] {
368                 uuid,
369                 
370                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
371             };
372 
373         Object result = null;
374 
375         if (finderClassNameCacheEnabled) {
376             result = FinderCacheUtil.getResult(finderClassName,
377                     finderMethodName, finderParams, finderArgs, this);
378         }
379 
380         if (result == null) {
381             Session session = null;
382 
383             try {
384                 session = openSession();
385 
386                 StringBuilder query = new StringBuilder();
387 
388                 query.append(
389                     "FROM com.liferay.portlet.bookmarks.model.BookmarksEntry WHERE ");
390 
391                 if (uuid == null) {
392                     query.append("uuid_ IS NULL");
393                 }
394                 else {
395                     query.append("uuid_ = ?");
396                 }
397 
398                 query.append(" ");
399 
400                 if (obc != null) {
401                     query.append("ORDER BY ");
402                     query.append(obc.getOrderBy());
403                 }
404 
405                 else {
406                     query.append("ORDER BY ");
407 
408                     query.append("folderId ASC, ");
409                     query.append("name ASC");
410                 }
411 
412                 Query q = session.createQuery(query.toString());
413 
414                 QueryPos qPos = QueryPos.getInstance(q);
415 
416                 if (uuid != null) {
417                     qPos.add(uuid);
418                 }
419 
420                 List<BookmarksEntry> list = (List<BookmarksEntry>)QueryUtil.list(q,
421                         getDialect(), start, end);
422 
423                 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
424                     finderClassName, finderMethodName, finderParams,
425                     finderArgs, list);
426 
427                 return list;
428             }
429             catch (Exception e) {
430                 throw processException(e);
431             }
432             finally {
433                 closeSession(session);
434             }
435         }
436         else {
437             return (List<BookmarksEntry>)result;
438         }
439     }
440 
441     public BookmarksEntry findByUuid_First(String uuid, OrderByComparator obc)
442         throws NoSuchEntryException, SystemException {
443         List<BookmarksEntry> list = findByUuid(uuid, 0, 1, obc);
444 
445         if (list.size() == 0) {
446             StringBuilder msg = new StringBuilder();
447 
448             msg.append("No BookmarksEntry exists with the key {");
449 
450             msg.append("uuid=" + uuid);
451 
452             msg.append(StringPool.CLOSE_CURLY_BRACE);
453 
454             throw new NoSuchEntryException(msg.toString());
455         }
456         else {
457             return list.get(0);
458         }
459     }
460 
461     public BookmarksEntry findByUuid_Last(String uuid, OrderByComparator obc)
462         throws NoSuchEntryException, SystemException {
463         int count = countByUuid(uuid);
464 
465         List<BookmarksEntry> list = findByUuid(uuid, count - 1, count, obc);
466 
467         if (list.size() == 0) {
468             StringBuilder msg = new StringBuilder();
469 
470             msg.append("No BookmarksEntry exists with the key {");
471 
472             msg.append("uuid=" + uuid);
473 
474             msg.append(StringPool.CLOSE_CURLY_BRACE);
475 
476             throw new NoSuchEntryException(msg.toString());
477         }
478         else {
479             return list.get(0);
480         }
481     }
482 
483     public BookmarksEntry[] findByUuid_PrevAndNext(long entryId, String uuid,
484         OrderByComparator obc) throws NoSuchEntryException, SystemException {
485         BookmarksEntry bookmarksEntry = findByPrimaryKey(entryId);
486 
487         int count = countByUuid(uuid);
488 
489         Session session = null;
490 
491         try {
492             session = openSession();
493 
494             StringBuilder query = new StringBuilder();
495 
496             query.append(
497                 "FROM com.liferay.portlet.bookmarks.model.BookmarksEntry WHERE ");
498 
499             if (uuid == null) {
500                 query.append("uuid_ IS NULL");
501             }
502             else {
503                 query.append("uuid_ = ?");
504             }
505 
506             query.append(" ");
507 
508             if (obc != null) {
509                 query.append("ORDER BY ");
510                 query.append(obc.getOrderBy());
511             }
512 
513             else {
514                 query.append("ORDER BY ");
515 
516                 query.append("folderId ASC, ");
517                 query.append("name ASC");
518             }
519 
520             Query q = session.createQuery(query.toString());
521 
522             QueryPos qPos = QueryPos.getInstance(q);
523 
524             if (uuid != null) {
525                 qPos.add(uuid);
526             }
527 
528             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
529                     bookmarksEntry);
530 
531             BookmarksEntry[] array = new BookmarksEntryImpl[3];
532 
533             array[0] = (BookmarksEntry)objArray[0];
534             array[1] = (BookmarksEntry)objArray[1];
535             array[2] = (BookmarksEntry)objArray[2];
536 
537             return array;
538         }
539         catch (Exception e) {
540             throw processException(e);
541         }
542         finally {
543             closeSession(session);
544         }
545     }
546 
547     public List<BookmarksEntry> findByFolderId(long folderId)
548         throws SystemException {
549         boolean finderClassNameCacheEnabled = BookmarksEntryModelImpl.CACHE_ENABLED;
550         String finderClassName = BookmarksEntry.class.getName();
551         String finderMethodName = "findByFolderId";
552         String[] finderParams = new String[] { Long.class.getName() };
553         Object[] finderArgs = new Object[] { new Long(folderId) };
554 
555         Object result = null;
556 
557         if (finderClassNameCacheEnabled) {
558             result = FinderCacheUtil.getResult(finderClassName,
559                     finderMethodName, finderParams, finderArgs, this);
560         }
561 
562         if (result == null) {
563             Session session = null;
564 
565             try {
566                 session = openSession();
567 
568                 StringBuilder query = new StringBuilder();
569 
570                 query.append(
571                     "FROM com.liferay.portlet.bookmarks.model.BookmarksEntry WHERE ");
572 
573                 query.append("folderId = ?");
574 
575                 query.append(" ");
576 
577                 query.append("ORDER BY ");
578 
579                 query.append("folderId ASC, ");
580                 query.append("name ASC");
581 
582                 Query q = session.createQuery(query.toString());
583 
584                 QueryPos qPos = QueryPos.getInstance(q);
585 
586                 qPos.add(folderId);
587 
588                 List<BookmarksEntry> list = q.list();
589 
590                 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
591                     finderClassName, finderMethodName, finderParams,
592                     finderArgs, list);
593 
594                 return list;
595             }
596             catch (Exception e) {
597                 throw processException(e);
598             }
599             finally {
600                 closeSession(session);
601             }
602         }
603         else {
604             return (List<BookmarksEntry>)result;
605         }
606     }
607 
608     public List<BookmarksEntry> findByFolderId(long folderId, int start, int end)
609         throws SystemException {
610         return findByFolderId(folderId, start, end, null);
611     }
612 
613     public List<BookmarksEntry> findByFolderId(long folderId, int start,
614         int end, OrderByComparator obc) throws SystemException {
615         boolean finderClassNameCacheEnabled = BookmarksEntryModelImpl.CACHE_ENABLED;
616         String finderClassName = BookmarksEntry.class.getName();
617         String finderMethodName = "findByFolderId";
618         String[] finderParams = new String[] {
619                 Long.class.getName(),
620                 
621                 "java.lang.Integer", "java.lang.Integer",
622                 "com.liferay.portal.kernel.util.OrderByComparator"
623             };
624         Object[] finderArgs = new Object[] {
625                 new Long(folderId),
626                 
627                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
628             };
629 
630         Object result = null;
631 
632         if (finderClassNameCacheEnabled) {
633             result = FinderCacheUtil.getResult(finderClassName,
634                     finderMethodName, finderParams, finderArgs, this);
635         }
636 
637         if (result == null) {
638             Session session = null;
639 
640             try {
641                 session = openSession();
642 
643                 StringBuilder query = new StringBuilder();
644 
645                 query.append(
646                     "FROM com.liferay.portlet.bookmarks.model.BookmarksEntry WHERE ");
647 
648                 query.append("folderId = ?");
649 
650                 query.append(" ");
651 
652                 if (obc != null) {
653                     query.append("ORDER BY ");
654                     query.append(obc.getOrderBy());
655                 }
656 
657                 else {
658                     query.append("ORDER BY ");
659 
660                     query.append("folderId ASC, ");
661                     query.append("name ASC");
662                 }
663 
664                 Query q = session.createQuery(query.toString());
665 
666                 QueryPos qPos = QueryPos.getInstance(q);
667 
668                 qPos.add(folderId);
669 
670                 List<BookmarksEntry> list = (List<BookmarksEntry>)QueryUtil.list(q,
671                         getDialect(), start, end);
672 
673                 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
674                     finderClassName, finderMethodName, finderParams,
675                     finderArgs, list);
676 
677                 return list;
678             }
679             catch (Exception e) {
680                 throw processException(e);
681             }
682             finally {
683                 closeSession(session);
684             }
685         }
686         else {
687             return (List<BookmarksEntry>)result;
688         }
689     }
690 
691     public BookmarksEntry findByFolderId_First(long folderId,
692         OrderByComparator obc) throws NoSuchEntryException, SystemException {
693         List<BookmarksEntry> list = findByFolderId(folderId, 0, 1, obc);
694 
695         if (list.size() == 0) {
696             StringBuilder msg = new StringBuilder();
697 
698             msg.append("No BookmarksEntry exists with the key {");
699 
700             msg.append("folderId=" + folderId);
701 
702             msg.append(StringPool.CLOSE_CURLY_BRACE);
703 
704             throw new NoSuchEntryException(msg.toString());
705         }
706         else {
707             return list.get(0);
708         }
709     }
710 
711     public BookmarksEntry findByFolderId_Last(long folderId,
712         OrderByComparator obc) throws NoSuchEntryException, SystemException {
713         int count = countByFolderId(folderId);
714 
715         List<BookmarksEntry> list = findByFolderId(folderId, count - 1, count,
716                 obc);
717 
718         if (list.size() == 0) {
719             StringBuilder msg = new StringBuilder();
720 
721             msg.append("No BookmarksEntry exists with the key {");
722 
723             msg.append("folderId=" + folderId);
724 
725             msg.append(StringPool.CLOSE_CURLY_BRACE);
726 
727             throw new NoSuchEntryException(msg.toString());
728         }
729         else {
730             return list.get(0);
731         }
732     }
733 
734     public BookmarksEntry[] findByFolderId_PrevAndNext(long entryId,
735         long folderId, OrderByComparator obc)
736         throws NoSuchEntryException, SystemException {
737         BookmarksEntry bookmarksEntry = findByPrimaryKey(entryId);
738 
739         int count = countByFolderId(folderId);
740 
741         Session session = null;
742 
743         try {
744             session = openSession();
745 
746             StringBuilder query = new StringBuilder();
747 
748             query.append(
749                 "FROM com.liferay.portlet.bookmarks.model.BookmarksEntry WHERE ");
750 
751             query.append("folderId = ?");
752 
753             query.append(" ");
754 
755             if (obc != null) {
756                 query.append("ORDER BY ");
757                 query.append(obc.getOrderBy());
758             }
759 
760             else {
761                 query.append("ORDER BY ");
762 
763                 query.append("folderId ASC, ");
764                 query.append("name ASC");
765             }
766 
767             Query q = session.createQuery(query.toString());
768 
769             QueryPos qPos = QueryPos.getInstance(q);
770 
771             qPos.add(folderId);
772 
773             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
774                     bookmarksEntry);
775 
776             BookmarksEntry[] array = new BookmarksEntryImpl[3];
777 
778             array[0] = (BookmarksEntry)objArray[0];
779             array[1] = (BookmarksEntry)objArray[1];
780             array[2] = (BookmarksEntry)objArray[2];
781 
782             return array;
783         }
784         catch (Exception e) {
785             throw processException(e);
786         }
787         finally {
788             closeSession(session);
789         }
790     }
791 
792     public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery)
793         throws SystemException {
794         Session session = null;
795 
796         try {
797             session = openSession();
798 
799             dynamicQuery.compile(session);
800 
801             return dynamicQuery.list();
802         }
803         catch (Exception e) {
804             throw processException(e);
805         }
806         finally {
807             closeSession(session);
808         }
809     }
810 
811     public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery,
812         int start, int end) throws SystemException {
813         Session session = null;
814 
815         try {
816             session = openSession();
817 
818             dynamicQuery.setLimit(start, end);
819 
820             dynamicQuery.compile(session);
821 
822             return dynamicQuery.list();
823         }
824         catch (Exception e) {
825             throw processException(e);
826         }
827         finally {
828             closeSession(session);
829         }
830     }
831 
832     public List<BookmarksEntry> findAll() throws SystemException {
833         return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
834     }
835 
836     public List<BookmarksEntry> findAll(int start, int end)
837         throws SystemException {
838         return findAll(start, end, null);
839     }
840 
841     public List<BookmarksEntry> findAll(int start, int end,
842         OrderByComparator obc) throws SystemException {
843         boolean finderClassNameCacheEnabled = BookmarksEntryModelImpl.CACHE_ENABLED;
844         String finderClassName = BookmarksEntry.class.getName();
845         String finderMethodName = "findAll";
846         String[] finderParams = new String[] {
847                 "java.lang.Integer", "java.lang.Integer",
848                 "com.liferay.portal.kernel.util.OrderByComparator"
849             };
850         Object[] finderArgs = new Object[] {
851                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
852             };
853 
854         Object result = null;
855 
856         if (finderClassNameCacheEnabled) {
857             result = FinderCacheUtil.getResult(finderClassName,
858                     finderMethodName, finderParams, finderArgs, this);
859         }
860 
861         if (result == null) {
862             Session session = null;
863 
864             try {
865                 session = openSession();
866 
867                 StringBuilder query = new StringBuilder();
868 
869                 query.append(
870                     "FROM com.liferay.portlet.bookmarks.model.BookmarksEntry ");
871 
872                 if (obc != null) {
873                     query.append("ORDER BY ");
874                     query.append(obc.getOrderBy());
875                 }
876 
877                 else {
878                     query.append("ORDER BY ");
879 
880                     query.append("folderId ASC, ");
881                     query.append("name ASC");
882                 }
883 
884                 Query q = session.createQuery(query.toString());
885 
886                 List<BookmarksEntry> list = null;
887 
888                 if (obc == null) {
889                     list = (List<BookmarksEntry>)QueryUtil.list(q,
890                             getDialect(), start, end, false);
891 
892                     Collections.sort(list);
893                 }
894                 else {
895                     list = (List<BookmarksEntry>)QueryUtil.list(q,
896                             getDialect(), start, end);
897                 }
898 
899                 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
900                     finderClassName, finderMethodName, finderParams,
901                     finderArgs, list);
902 
903                 return list;
904             }
905             catch (Exception e) {
906                 throw processException(e);
907             }
908             finally {
909                 closeSession(session);
910             }
911         }
912         else {
913             return (List<BookmarksEntry>)result;
914         }
915     }
916 
917     public void removeByUuid(String uuid) throws SystemException {
918         for (BookmarksEntry bookmarksEntry : findByUuid(uuid)) {
919             remove(bookmarksEntry);
920         }
921     }
922 
923     public void removeByFolderId(long folderId) throws SystemException {
924         for (BookmarksEntry bookmarksEntry : findByFolderId(folderId)) {
925             remove(bookmarksEntry);
926         }
927     }
928 
929     public void removeAll() throws SystemException {
930         for (BookmarksEntry bookmarksEntry : findAll()) {
931             remove(bookmarksEntry);
932         }
933     }
934 
935     public int countByUuid(String uuid) throws SystemException {
936         boolean finderClassNameCacheEnabled = BookmarksEntryModelImpl.CACHE_ENABLED;
937         String finderClassName = BookmarksEntry.class.getName();
938         String finderMethodName = "countByUuid";
939         String[] finderParams = new String[] { String.class.getName() };
940         Object[] finderArgs = new Object[] { uuid };
941 
942         Object result = null;
943 
944         if (finderClassNameCacheEnabled) {
945             result = FinderCacheUtil.getResult(finderClassName,
946                     finderMethodName, finderParams, finderArgs, this);
947         }
948 
949         if (result == null) {
950             Session session = null;
951 
952             try {
953                 session = openSession();
954 
955                 StringBuilder query = new StringBuilder();
956 
957                 query.append("SELECT COUNT(*) ");
958                 query.append(
959                     "FROM com.liferay.portlet.bookmarks.model.BookmarksEntry WHERE ");
960 
961                 if (uuid == null) {
962                     query.append("uuid_ IS NULL");
963                 }
964                 else {
965                     query.append("uuid_ = ?");
966                 }
967 
968                 query.append(" ");
969 
970                 Query q = session.createQuery(query.toString());
971 
972                 QueryPos qPos = QueryPos.getInstance(q);
973 
974                 if (uuid != null) {
975                     qPos.add(uuid);
976                 }
977 
978                 Long count = null;
979 
980                 Iterator<Long> itr = q.list().iterator();
981 
982                 if (itr.hasNext()) {
983                     count = itr.next();
984                 }
985 
986                 if (count == null) {
987                     count = new Long(0);
988                 }
989 
990                 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
991                     finderClassName, finderMethodName, finderParams,
992                     finderArgs, count);
993 
994                 return count.intValue();
995             }
996             catch (Exception e) {
997                 throw processException(e);
998             }
999             finally {
1000                closeSession(session);
1001            }
1002        }
1003        else {
1004            return ((Long)result).intValue();
1005        }
1006    }
1007
1008    public int countByFolderId(long folderId) throws SystemException {
1009        boolean finderClassNameCacheEnabled = BookmarksEntryModelImpl.CACHE_ENABLED;
1010        String finderClassName = BookmarksEntry.class.getName();
1011        String finderMethodName = "countByFolderId";
1012        String[] finderParams = new String[] { Long.class.getName() };
1013        Object[] finderArgs = new Object[] { new Long(folderId) };
1014
1015        Object result = null;
1016
1017        if (finderClassNameCacheEnabled) {
1018            result = FinderCacheUtil.getResult(finderClassName,
1019                    finderMethodName, finderParams, finderArgs, this);
1020        }
1021
1022        if (result == null) {
1023            Session session = null;
1024
1025            try {
1026                session = openSession();
1027
1028                StringBuilder query = new StringBuilder();
1029
1030                query.append("SELECT COUNT(*) ");
1031                query.append(
1032                    "FROM com.liferay.portlet.bookmarks.model.BookmarksEntry WHERE ");
1033
1034                query.append("folderId = ?");
1035
1036                query.append(" ");
1037
1038                Query q = session.createQuery(query.toString());
1039
1040                QueryPos qPos = QueryPos.getInstance(q);
1041
1042                qPos.add(folderId);
1043
1044                Long count = null;
1045
1046                Iterator<Long> itr = q.list().iterator();
1047
1048                if (itr.hasNext()) {
1049                    count = itr.next();
1050                }
1051
1052                if (count == null) {
1053                    count = new Long(0);
1054                }
1055
1056                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1057                    finderClassName, finderMethodName, finderParams,
1058                    finderArgs, count);
1059
1060                return count.intValue();
1061            }
1062            catch (Exception e) {
1063                throw processException(e);
1064            }
1065            finally {
1066                closeSession(session);
1067            }
1068        }
1069        else {
1070            return ((Long)result).intValue();
1071        }
1072    }
1073
1074    public int countAll() throws SystemException {
1075        boolean finderClassNameCacheEnabled = BookmarksEntryModelImpl.CACHE_ENABLED;
1076        String finderClassName = BookmarksEntry.class.getName();
1077        String finderMethodName = "countAll";
1078        String[] finderParams = new String[] {  };
1079        Object[] finderArgs = new Object[] {  };
1080
1081        Object result = null;
1082
1083        if (finderClassNameCacheEnabled) {
1084            result = FinderCacheUtil.getResult(finderClassName,
1085                    finderMethodName, finderParams, finderArgs, this);
1086        }
1087
1088        if (result == null) {
1089            Session session = null;
1090
1091            try {
1092                session = openSession();
1093
1094                Query q = session.createQuery(
1095                        "SELECT COUNT(*) FROM com.liferay.portlet.bookmarks.model.BookmarksEntry");
1096
1097                Long count = null;
1098
1099                Iterator<Long> itr = q.list().iterator();
1100
1101                if (itr.hasNext()) {
1102                    count = itr.next();
1103                }
1104
1105                if (count == null) {
1106                    count = new Long(0);
1107                }
1108
1109                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1110                    finderClassName, finderMethodName, finderParams,
1111                    finderArgs, count);
1112
1113                return count.intValue();
1114            }
1115            catch (Exception e) {
1116                throw processException(e);
1117            }
1118            finally {
1119                closeSession(session);
1120            }
1121        }
1122        else {
1123            return ((Long)result).intValue();
1124        }
1125    }
1126
1127    public void registerListener(ModelListener listener) {
1128        List<ModelListener> listeners = ListUtil.fromArray(_listeners);
1129
1130        listeners.add(listener);
1131
1132        _listeners = listeners.toArray(new ModelListener[listeners.size()]);
1133    }
1134
1135    public void unregisterListener(ModelListener listener) {
1136        List<ModelListener> listeners = ListUtil.fromArray(_listeners);
1137
1138        listeners.remove(listener);
1139
1140        _listeners = listeners.toArray(new ModelListener[listeners.size()]);
1141    }
1142
1143    public void afterPropertiesSet() {
1144        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
1145                    com.liferay.portal.util.PropsUtil.get(
1146                        "value.object.listener.com.liferay.portlet.bookmarks.model.BookmarksEntry")));
1147
1148        if (listenerClassNames.length > 0) {
1149            try {
1150                List<ModelListener> listeners = new ArrayList<ModelListener>();
1151
1152                for (String listenerClassName : listenerClassNames) {
1153                    listeners.add((ModelListener)Class.forName(
1154                            listenerClassName).newInstance());
1155                }
1156
1157                _listeners = listeners.toArray(new ModelListener[listeners.size()]);
1158            }
1159            catch (Exception e) {
1160                _log.error(e);
1161            }
1162        }
1163    }
1164
1165    private static Log _log = LogFactory.getLog(BookmarksEntryPersistenceImpl.class);
1166    private ModelListener[] _listeners = new ModelListener[0];
1167}