1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * The contents of this file are subject to the terms of the Liferay Enterprise
5    * Subscription License ("License"). You may not use this file except in
6    * compliance with the License. You can obtain a copy of the License by
7    * contacting Liferay, Inc. See the License for the specific language governing
8    * permissions and limitations under the License, including but not limited to
9    * distribution rights of the Software.
10   *
11   *
12   * 
13   */
14  
15  package com.liferay.portlet.bookmarks.service.persistence;
16  
17  import com.liferay.portal.NoSuchModelException;
18  import com.liferay.portal.SystemException;
19  import com.liferay.portal.kernel.annotation.BeanReference;
20  import com.liferay.portal.kernel.cache.CacheRegistry;
21  import com.liferay.portal.kernel.dao.orm.DynamicQuery;
22  import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
23  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
24  import com.liferay.portal.kernel.dao.orm.FinderPath;
25  import com.liferay.portal.kernel.dao.orm.Query;
26  import com.liferay.portal.kernel.dao.orm.QueryPos;
27  import com.liferay.portal.kernel.dao.orm.QueryUtil;
28  import com.liferay.portal.kernel.dao.orm.Session;
29  import com.liferay.portal.kernel.log.Log;
30  import com.liferay.portal.kernel.log.LogFactoryUtil;
31  import com.liferay.portal.kernel.util.GetterUtil;
32  import com.liferay.portal.kernel.util.OrderByComparator;
33  import com.liferay.portal.kernel.util.StringBundler;
34  import com.liferay.portal.kernel.util.StringPool;
35  import com.liferay.portal.kernel.util.StringUtil;
36  import com.liferay.portal.kernel.util.Validator;
37  import com.liferay.portal.kernel.uuid.PortalUUIDUtil;
38  import com.liferay.portal.model.ModelListener;
39  import com.liferay.portal.service.persistence.BatchSessionUtil;
40  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
41  
42  import com.liferay.portlet.bookmarks.NoSuchFolderException;
43  import com.liferay.portlet.bookmarks.model.BookmarksFolder;
44  import com.liferay.portlet.bookmarks.model.impl.BookmarksFolderImpl;
45  import com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl;
46  
47  import java.io.Serializable;
48  
49  import java.util.ArrayList;
50  import java.util.Collections;
51  import java.util.List;
52  
53  /**
54   * <a href="BookmarksFolderPersistenceImpl.java.html"><b><i>View Source</i></b></a>
55   *
56   * <p>
57   * ServiceBuilder generated this class. Modifications in this class will be
58   * overwritten the next time is generated.
59   * </p>
60   *
61   * @author    Brian Wing Shun Chan
62   * @see       BookmarksFolderPersistence
63   * @see       BookmarksFolderUtil
64   * @generated
65   */
66  public class BookmarksFolderPersistenceImpl extends BasePersistenceImpl<BookmarksFolder>
67      implements BookmarksFolderPersistence {
68      public static final String FINDER_CLASS_NAME_ENTITY = BookmarksFolderImpl.class.getName();
69      public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
70          ".List";
71      public static final FinderPath FINDER_PATH_FIND_BY_UUID = new FinderPath(BookmarksFolderModelImpl.ENTITY_CACHE_ENABLED,
72              BookmarksFolderModelImpl.FINDER_CACHE_ENABLED,
73              FINDER_CLASS_NAME_LIST, "findByUuid",
74              new String[] { String.class.getName() });
75      public static final FinderPath FINDER_PATH_FIND_BY_OBC_UUID = new FinderPath(BookmarksFolderModelImpl.ENTITY_CACHE_ENABLED,
76              BookmarksFolderModelImpl.FINDER_CACHE_ENABLED,
77              FINDER_CLASS_NAME_LIST, "findByUuid",
78              new String[] {
79                  String.class.getName(),
80                  
81              "java.lang.Integer", "java.lang.Integer",
82                  "com.liferay.portal.kernel.util.OrderByComparator"
83              });
84      public static final FinderPath FINDER_PATH_COUNT_BY_UUID = new FinderPath(BookmarksFolderModelImpl.ENTITY_CACHE_ENABLED,
85              BookmarksFolderModelImpl.FINDER_CACHE_ENABLED,
86              FINDER_CLASS_NAME_LIST, "countByUuid",
87              new String[] { String.class.getName() });
88      public static final FinderPath FINDER_PATH_FETCH_BY_UUID_G = new FinderPath(BookmarksFolderModelImpl.ENTITY_CACHE_ENABLED,
89              BookmarksFolderModelImpl.FINDER_CACHE_ENABLED,
90              FINDER_CLASS_NAME_ENTITY, "fetchByUUID_G",
91              new String[] { String.class.getName(), Long.class.getName() });
92      public static final FinderPath FINDER_PATH_COUNT_BY_UUID_G = new FinderPath(BookmarksFolderModelImpl.ENTITY_CACHE_ENABLED,
93              BookmarksFolderModelImpl.FINDER_CACHE_ENABLED,
94              FINDER_CLASS_NAME_LIST, "countByUUID_G",
95              new String[] { String.class.getName(), Long.class.getName() });
96      public static final FinderPath FINDER_PATH_FIND_BY_GROUPID = new FinderPath(BookmarksFolderModelImpl.ENTITY_CACHE_ENABLED,
97              BookmarksFolderModelImpl.FINDER_CACHE_ENABLED,
98              FINDER_CLASS_NAME_LIST, "findByGroupId",
99              new String[] { Long.class.getName() });
100     public static final FinderPath FINDER_PATH_FIND_BY_OBC_GROUPID = new FinderPath(BookmarksFolderModelImpl.ENTITY_CACHE_ENABLED,
101             BookmarksFolderModelImpl.FINDER_CACHE_ENABLED,
102             FINDER_CLASS_NAME_LIST, "findByGroupId",
103             new String[] {
104                 Long.class.getName(),
105                 
106             "java.lang.Integer", "java.lang.Integer",
107                 "com.liferay.portal.kernel.util.OrderByComparator"
108             });
109     public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(BookmarksFolderModelImpl.ENTITY_CACHE_ENABLED,
110             BookmarksFolderModelImpl.FINDER_CACHE_ENABLED,
111             FINDER_CLASS_NAME_LIST, "countByGroupId",
112             new String[] { Long.class.getName() });
113     public static final FinderPath FINDER_PATH_FIND_BY_COMPANYID = new FinderPath(BookmarksFolderModelImpl.ENTITY_CACHE_ENABLED,
114             BookmarksFolderModelImpl.FINDER_CACHE_ENABLED,
115             FINDER_CLASS_NAME_LIST, "findByCompanyId",
116             new String[] { Long.class.getName() });
117     public static final FinderPath FINDER_PATH_FIND_BY_OBC_COMPANYID = new FinderPath(BookmarksFolderModelImpl.ENTITY_CACHE_ENABLED,
118             BookmarksFolderModelImpl.FINDER_CACHE_ENABLED,
119             FINDER_CLASS_NAME_LIST, "findByCompanyId",
120             new String[] {
121                 Long.class.getName(),
122                 
123             "java.lang.Integer", "java.lang.Integer",
124                 "com.liferay.portal.kernel.util.OrderByComparator"
125             });
126     public static final FinderPath FINDER_PATH_COUNT_BY_COMPANYID = new FinderPath(BookmarksFolderModelImpl.ENTITY_CACHE_ENABLED,
127             BookmarksFolderModelImpl.FINDER_CACHE_ENABLED,
128             FINDER_CLASS_NAME_LIST, "countByCompanyId",
129             new String[] { Long.class.getName() });
130     public static final FinderPath FINDER_PATH_FIND_BY_G_P = new FinderPath(BookmarksFolderModelImpl.ENTITY_CACHE_ENABLED,
131             BookmarksFolderModelImpl.FINDER_CACHE_ENABLED,
132             FINDER_CLASS_NAME_LIST, "findByG_P",
133             new String[] { Long.class.getName(), Long.class.getName() });
134     public static final FinderPath FINDER_PATH_FIND_BY_OBC_G_P = new FinderPath(BookmarksFolderModelImpl.ENTITY_CACHE_ENABLED,
135             BookmarksFolderModelImpl.FINDER_CACHE_ENABLED,
136             FINDER_CLASS_NAME_LIST, "findByG_P",
137             new String[] {
138                 Long.class.getName(), Long.class.getName(),
139                 
140             "java.lang.Integer", "java.lang.Integer",
141                 "com.liferay.portal.kernel.util.OrderByComparator"
142             });
143     public static final FinderPath FINDER_PATH_COUNT_BY_G_P = new FinderPath(BookmarksFolderModelImpl.ENTITY_CACHE_ENABLED,
144             BookmarksFolderModelImpl.FINDER_CACHE_ENABLED,
145             FINDER_CLASS_NAME_LIST, "countByG_P",
146             new String[] { Long.class.getName(), Long.class.getName() });
147     public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(BookmarksFolderModelImpl.ENTITY_CACHE_ENABLED,
148             BookmarksFolderModelImpl.FINDER_CACHE_ENABLED,
149             FINDER_CLASS_NAME_LIST, "findAll", new String[0]);
150     public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(BookmarksFolderModelImpl.ENTITY_CACHE_ENABLED,
151             BookmarksFolderModelImpl.FINDER_CACHE_ENABLED,
152             FINDER_CLASS_NAME_LIST, "countAll", new String[0]);
153 
154     public void cacheResult(BookmarksFolder bookmarksFolder) {
155         EntityCacheUtil.putResult(BookmarksFolderModelImpl.ENTITY_CACHE_ENABLED,
156             BookmarksFolderImpl.class, bookmarksFolder.getPrimaryKey(),
157             bookmarksFolder);
158 
159         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
160             new Object[] {
161                 bookmarksFolder.getUuid(),
162                 new Long(bookmarksFolder.getGroupId())
163             }, bookmarksFolder);
164     }
165 
166     public void cacheResult(List<BookmarksFolder> bookmarksFolders) {
167         for (BookmarksFolder bookmarksFolder : bookmarksFolders) {
168             if (EntityCacheUtil.getResult(
169                         BookmarksFolderModelImpl.ENTITY_CACHE_ENABLED,
170                         BookmarksFolderImpl.class,
171                         bookmarksFolder.getPrimaryKey(), this) == null) {
172                 cacheResult(bookmarksFolder);
173             }
174         }
175     }
176 
177     public void clearCache() {
178         CacheRegistry.clear(BookmarksFolderImpl.class.getName());
179         EntityCacheUtil.clearCache(BookmarksFolderImpl.class.getName());
180         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
181         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
182     }
183 
184     public BookmarksFolder create(long folderId) {
185         BookmarksFolder bookmarksFolder = new BookmarksFolderImpl();
186 
187         bookmarksFolder.setNew(true);
188         bookmarksFolder.setPrimaryKey(folderId);
189 
190         String uuid = PortalUUIDUtil.generate();
191 
192         bookmarksFolder.setUuid(uuid);
193 
194         return bookmarksFolder;
195     }
196 
197     public BookmarksFolder remove(Serializable primaryKey)
198         throws NoSuchModelException, SystemException {
199         return remove(((Long)primaryKey).longValue());
200     }
201 
202     public BookmarksFolder remove(long folderId)
203         throws NoSuchFolderException, SystemException {
204         Session session = null;
205 
206         try {
207             session = openSession();
208 
209             BookmarksFolder bookmarksFolder = (BookmarksFolder)session.get(BookmarksFolderImpl.class,
210                     new Long(folderId));
211 
212             if (bookmarksFolder == null) {
213                 if (_log.isWarnEnabled()) {
214                     _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + folderId);
215                 }
216 
217                 throw new NoSuchFolderException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
218                     folderId);
219             }
220 
221             return remove(bookmarksFolder);
222         }
223         catch (NoSuchFolderException nsee) {
224             throw nsee;
225         }
226         catch (Exception e) {
227             throw processException(e);
228         }
229         finally {
230             closeSession(session);
231         }
232     }
233 
234     public BookmarksFolder remove(BookmarksFolder bookmarksFolder)
235         throws SystemException {
236         for (ModelListener<BookmarksFolder> listener : listeners) {
237             listener.onBeforeRemove(bookmarksFolder);
238         }
239 
240         bookmarksFolder = removeImpl(bookmarksFolder);
241 
242         for (ModelListener<BookmarksFolder> listener : listeners) {
243             listener.onAfterRemove(bookmarksFolder);
244         }
245 
246         return bookmarksFolder;
247     }
248 
249     protected BookmarksFolder removeImpl(BookmarksFolder bookmarksFolder)
250         throws SystemException {
251         bookmarksFolder = toUnwrappedModel(bookmarksFolder);
252 
253         Session session = null;
254 
255         try {
256             session = openSession();
257 
258             if (bookmarksFolder.isCachedModel() ||
259                     BatchSessionUtil.isEnabled()) {
260                 Object staleObject = session.get(BookmarksFolderImpl.class,
261                         bookmarksFolder.getPrimaryKeyObj());
262 
263                 if (staleObject != null) {
264                     session.evict(staleObject);
265                 }
266             }
267 
268             session.delete(bookmarksFolder);
269 
270             session.flush();
271         }
272         catch (Exception e) {
273             throw processException(e);
274         }
275         finally {
276             closeSession(session);
277         }
278 
279         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
280 
281         BookmarksFolderModelImpl bookmarksFolderModelImpl = (BookmarksFolderModelImpl)bookmarksFolder;
282 
283         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
284             new Object[] {
285                 bookmarksFolderModelImpl.getOriginalUuid(),
286                 new Long(bookmarksFolderModelImpl.getOriginalGroupId())
287             });
288 
289         EntityCacheUtil.removeResult(BookmarksFolderModelImpl.ENTITY_CACHE_ENABLED,
290             BookmarksFolderImpl.class, bookmarksFolder.getPrimaryKey());
291 
292         return bookmarksFolder;
293     }
294 
295     /**
296      * @deprecated Use {@link BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)}.
297      */
298     public BookmarksFolder update(BookmarksFolder bookmarksFolder)
299         throws SystemException {
300         if (_log.isWarnEnabled()) {
301             _log.warn(
302                 "Using the deprecated update(BookmarksFolder bookmarksFolder) method. Use update(BookmarksFolder bookmarksFolder, boolean merge) instead.");
303         }
304 
305         return update(bookmarksFolder, false);
306     }
307 
308     public BookmarksFolder updateImpl(
309         com.liferay.portlet.bookmarks.model.BookmarksFolder bookmarksFolder,
310         boolean merge) throws SystemException {
311         bookmarksFolder = toUnwrappedModel(bookmarksFolder);
312 
313         boolean isNew = bookmarksFolder.isNew();
314 
315         BookmarksFolderModelImpl bookmarksFolderModelImpl = (BookmarksFolderModelImpl)bookmarksFolder;
316 
317         if (Validator.isNull(bookmarksFolder.getUuid())) {
318             String uuid = PortalUUIDUtil.generate();
319 
320             bookmarksFolder.setUuid(uuid);
321         }
322 
323         Session session = null;
324 
325         try {
326             session = openSession();
327 
328             BatchSessionUtil.update(session, bookmarksFolder, merge);
329 
330             bookmarksFolder.setNew(false);
331         }
332         catch (Exception e) {
333             throw processException(e);
334         }
335         finally {
336             closeSession(session);
337         }
338 
339         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
340 
341         EntityCacheUtil.putResult(BookmarksFolderModelImpl.ENTITY_CACHE_ENABLED,
342             BookmarksFolderImpl.class, bookmarksFolder.getPrimaryKey(),
343             bookmarksFolder);
344 
345         if (!isNew &&
346                 (!Validator.equals(bookmarksFolder.getUuid(),
347                     bookmarksFolderModelImpl.getOriginalUuid()) ||
348                 (bookmarksFolder.getGroupId() != bookmarksFolderModelImpl.getOriginalGroupId()))) {
349             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
350                 new Object[] {
351                     bookmarksFolderModelImpl.getOriginalUuid(),
352                     new Long(bookmarksFolderModelImpl.getOriginalGroupId())
353                 });
354         }
355 
356         if (isNew ||
357                 (!Validator.equals(bookmarksFolder.getUuid(),
358                     bookmarksFolderModelImpl.getOriginalUuid()) ||
359                 (bookmarksFolder.getGroupId() != bookmarksFolderModelImpl.getOriginalGroupId()))) {
360             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
361                 new Object[] {
362                     bookmarksFolder.getUuid(),
363                     new Long(bookmarksFolder.getGroupId())
364                 }, bookmarksFolder);
365         }
366 
367         return bookmarksFolder;
368     }
369 
370     protected BookmarksFolder toUnwrappedModel(BookmarksFolder bookmarksFolder) {
371         if (bookmarksFolder instanceof BookmarksFolderImpl) {
372             return bookmarksFolder;
373         }
374 
375         BookmarksFolderImpl bookmarksFolderImpl = new BookmarksFolderImpl();
376 
377         bookmarksFolderImpl.setNew(bookmarksFolder.isNew());
378         bookmarksFolderImpl.setPrimaryKey(bookmarksFolder.getPrimaryKey());
379 
380         bookmarksFolderImpl.setUuid(bookmarksFolder.getUuid());
381         bookmarksFolderImpl.setFolderId(bookmarksFolder.getFolderId());
382         bookmarksFolderImpl.setGroupId(bookmarksFolder.getGroupId());
383         bookmarksFolderImpl.setCompanyId(bookmarksFolder.getCompanyId());
384         bookmarksFolderImpl.setUserId(bookmarksFolder.getUserId());
385         bookmarksFolderImpl.setCreateDate(bookmarksFolder.getCreateDate());
386         bookmarksFolderImpl.setModifiedDate(bookmarksFolder.getModifiedDate());
387         bookmarksFolderImpl.setParentFolderId(bookmarksFolder.getParentFolderId());
388         bookmarksFolderImpl.setName(bookmarksFolder.getName());
389         bookmarksFolderImpl.setDescription(bookmarksFolder.getDescription());
390 
391         return bookmarksFolderImpl;
392     }
393 
394     public BookmarksFolder findByPrimaryKey(Serializable primaryKey)
395         throws NoSuchModelException, SystemException {
396         return findByPrimaryKey(((Long)primaryKey).longValue());
397     }
398 
399     public BookmarksFolder findByPrimaryKey(long folderId)
400         throws NoSuchFolderException, SystemException {
401         BookmarksFolder bookmarksFolder = fetchByPrimaryKey(folderId);
402 
403         if (bookmarksFolder == null) {
404             if (_log.isWarnEnabled()) {
405                 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + folderId);
406             }
407 
408             throw new NoSuchFolderException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
409                 folderId);
410         }
411 
412         return bookmarksFolder;
413     }
414 
415     public BookmarksFolder fetchByPrimaryKey(Serializable primaryKey)
416         throws SystemException {
417         return fetchByPrimaryKey(((Long)primaryKey).longValue());
418     }
419 
420     public BookmarksFolder fetchByPrimaryKey(long folderId)
421         throws SystemException {
422         BookmarksFolder bookmarksFolder = (BookmarksFolder)EntityCacheUtil.getResult(BookmarksFolderModelImpl.ENTITY_CACHE_ENABLED,
423                 BookmarksFolderImpl.class, folderId, this);
424 
425         if (bookmarksFolder == null) {
426             Session session = null;
427 
428             try {
429                 session = openSession();
430 
431                 bookmarksFolder = (BookmarksFolder)session.get(BookmarksFolderImpl.class,
432                         new Long(folderId));
433             }
434             catch (Exception e) {
435                 throw processException(e);
436             }
437             finally {
438                 if (bookmarksFolder != null) {
439                     cacheResult(bookmarksFolder);
440                 }
441 
442                 closeSession(session);
443             }
444         }
445 
446         return bookmarksFolder;
447     }
448 
449     public List<BookmarksFolder> findByUuid(String uuid)
450         throws SystemException {
451         Object[] finderArgs = new Object[] { uuid };
452 
453         List<BookmarksFolder> list = (List<BookmarksFolder>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_UUID,
454                 finderArgs, this);
455 
456         if (list == null) {
457             Session session = null;
458 
459             try {
460                 session = openSession();
461 
462                 StringBundler query = new StringBundler(3);
463 
464                 query.append(_SQL_SELECT_BOOKMARKSFOLDER_WHERE);
465 
466                 if (uuid == null) {
467                     query.append(_FINDER_COLUMN_UUID_UUID_1);
468                 }
469                 else {
470                     if (uuid.equals(StringPool.BLANK)) {
471                         query.append(_FINDER_COLUMN_UUID_UUID_3);
472                     }
473                     else {
474                         query.append(_FINDER_COLUMN_UUID_UUID_2);
475                     }
476                 }
477 
478                 query.append(BookmarksFolderModelImpl.ORDER_BY_JPQL);
479 
480                 String sql = query.toString();
481 
482                 Query q = session.createQuery(sql);
483 
484                 QueryPos qPos = QueryPos.getInstance(q);
485 
486                 if (uuid != null) {
487                     qPos.add(uuid);
488                 }
489 
490                 list = q.list();
491             }
492             catch (Exception e) {
493                 throw processException(e);
494             }
495             finally {
496                 if (list == null) {
497                     list = new ArrayList<BookmarksFolder>();
498                 }
499 
500                 cacheResult(list);
501 
502                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_UUID, finderArgs,
503                     list);
504 
505                 closeSession(session);
506             }
507         }
508 
509         return list;
510     }
511 
512     public List<BookmarksFolder> findByUuid(String uuid, int start, int end)
513         throws SystemException {
514         return findByUuid(uuid, start, end, null);
515     }
516 
517     public List<BookmarksFolder> findByUuid(String uuid, int start, int end,
518         OrderByComparator obc) throws SystemException {
519         Object[] finderArgs = new Object[] {
520                 uuid,
521                 
522                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
523             };
524 
525         List<BookmarksFolder> list = (List<BookmarksFolder>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_UUID,
526                 finderArgs, this);
527 
528         if (list == null) {
529             Session session = null;
530 
531             try {
532                 session = openSession();
533 
534                 StringBundler query = null;
535 
536                 if (obc != null) {
537                     query = new StringBundler(3 +
538                             (obc.getOrderByFields().length * 3));
539                 }
540                 else {
541                     query = new StringBundler(3);
542                 }
543 
544                 query.append(_SQL_SELECT_BOOKMARKSFOLDER_WHERE);
545 
546                 if (uuid == null) {
547                     query.append(_FINDER_COLUMN_UUID_UUID_1);
548                 }
549                 else {
550                     if (uuid.equals(StringPool.BLANK)) {
551                         query.append(_FINDER_COLUMN_UUID_UUID_3);
552                     }
553                     else {
554                         query.append(_FINDER_COLUMN_UUID_UUID_2);
555                     }
556                 }
557 
558                 if (obc != null) {
559                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
560                 }
561 
562                 else {
563                     query.append(BookmarksFolderModelImpl.ORDER_BY_JPQL);
564                 }
565 
566                 String sql = query.toString();
567 
568                 Query q = session.createQuery(sql);
569 
570                 QueryPos qPos = QueryPos.getInstance(q);
571 
572                 if (uuid != null) {
573                     qPos.add(uuid);
574                 }
575 
576                 list = (List<BookmarksFolder>)QueryUtil.list(q, getDialect(),
577                         start, end);
578             }
579             catch (Exception e) {
580                 throw processException(e);
581             }
582             finally {
583                 if (list == null) {
584                     list = new ArrayList<BookmarksFolder>();
585                 }
586 
587                 cacheResult(list);
588 
589                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_UUID,
590                     finderArgs, list);
591 
592                 closeSession(session);
593             }
594         }
595 
596         return list;
597     }
598 
599     public BookmarksFolder findByUuid_First(String uuid, OrderByComparator obc)
600         throws NoSuchFolderException, SystemException {
601         List<BookmarksFolder> list = findByUuid(uuid, 0, 1, obc);
602 
603         if (list.isEmpty()) {
604             StringBundler msg = new StringBundler(4);
605 
606             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
607 
608             msg.append("uuid=");
609             msg.append(uuid);
610 
611             msg.append(StringPool.CLOSE_CURLY_BRACE);
612 
613             throw new NoSuchFolderException(msg.toString());
614         }
615         else {
616             return list.get(0);
617         }
618     }
619 
620     public BookmarksFolder findByUuid_Last(String uuid, OrderByComparator obc)
621         throws NoSuchFolderException, SystemException {
622         int count = countByUuid(uuid);
623 
624         List<BookmarksFolder> list = findByUuid(uuid, count - 1, count, obc);
625 
626         if (list.isEmpty()) {
627             StringBundler msg = new StringBundler(4);
628 
629             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
630 
631             msg.append("uuid=");
632             msg.append(uuid);
633 
634             msg.append(StringPool.CLOSE_CURLY_BRACE);
635 
636             throw new NoSuchFolderException(msg.toString());
637         }
638         else {
639             return list.get(0);
640         }
641     }
642 
643     public BookmarksFolder[] findByUuid_PrevAndNext(long folderId, String uuid,
644         OrderByComparator obc) throws NoSuchFolderException, SystemException {
645         BookmarksFolder bookmarksFolder = findByPrimaryKey(folderId);
646 
647         int count = countByUuid(uuid);
648 
649         Session session = null;
650 
651         try {
652             session = openSession();
653 
654             StringBundler query = null;
655 
656             if (obc != null) {
657                 query = new StringBundler(3 +
658                         (obc.getOrderByFields().length * 3));
659             }
660             else {
661                 query = new StringBundler(3);
662             }
663 
664             query.append(_SQL_SELECT_BOOKMARKSFOLDER_WHERE);
665 
666             if (uuid == null) {
667                 query.append(_FINDER_COLUMN_UUID_UUID_1);
668             }
669             else {
670                 if (uuid.equals(StringPool.BLANK)) {
671                     query.append(_FINDER_COLUMN_UUID_UUID_3);
672                 }
673                 else {
674                     query.append(_FINDER_COLUMN_UUID_UUID_2);
675                 }
676             }
677 
678             if (obc != null) {
679                 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
680             }
681 
682             else {
683                 query.append(BookmarksFolderModelImpl.ORDER_BY_JPQL);
684             }
685 
686             String sql = query.toString();
687 
688             Query q = session.createQuery(sql);
689 
690             QueryPos qPos = QueryPos.getInstance(q);
691 
692             if (uuid != null) {
693                 qPos.add(uuid);
694             }
695 
696             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
697                     bookmarksFolder);
698 
699             BookmarksFolder[] array = new BookmarksFolderImpl[3];
700 
701             array[0] = (BookmarksFolder)objArray[0];
702             array[1] = (BookmarksFolder)objArray[1];
703             array[2] = (BookmarksFolder)objArray[2];
704 
705             return array;
706         }
707         catch (Exception e) {
708             throw processException(e);
709         }
710         finally {
711             closeSession(session);
712         }
713     }
714 
715     public BookmarksFolder findByUUID_G(String uuid, long groupId)
716         throws NoSuchFolderException, SystemException {
717         BookmarksFolder bookmarksFolder = fetchByUUID_G(uuid, groupId);
718 
719         if (bookmarksFolder == null) {
720             StringBundler msg = new StringBundler(6);
721 
722             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
723 
724             msg.append("uuid=");
725             msg.append(uuid);
726 
727             msg.append(", groupId=");
728             msg.append(groupId);
729 
730             msg.append(StringPool.CLOSE_CURLY_BRACE);
731 
732             if (_log.isWarnEnabled()) {
733                 _log.warn(msg.toString());
734             }
735 
736             throw new NoSuchFolderException(msg.toString());
737         }
738 
739         return bookmarksFolder;
740     }
741 
742     public BookmarksFolder fetchByUUID_G(String uuid, long groupId)
743         throws SystemException {
744         return fetchByUUID_G(uuid, groupId, true);
745     }
746 
747     public BookmarksFolder fetchByUUID_G(String uuid, long groupId,
748         boolean retrieveFromCache) throws SystemException {
749         Object[] finderArgs = new Object[] { uuid, new Long(groupId) };
750 
751         Object result = null;
752 
753         if (retrieveFromCache) {
754             result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_UUID_G,
755                     finderArgs, this);
756         }
757 
758         if (result == null) {
759             Session session = null;
760 
761             try {
762                 session = openSession();
763 
764                 StringBundler query = new StringBundler(4);
765 
766                 query.append(_SQL_SELECT_BOOKMARKSFOLDER_WHERE);
767 
768                 if (uuid == null) {
769                     query.append(_FINDER_COLUMN_UUID_G_UUID_1);
770                 }
771                 else {
772                     if (uuid.equals(StringPool.BLANK)) {
773                         query.append(_FINDER_COLUMN_UUID_G_UUID_3);
774                     }
775                     else {
776                         query.append(_FINDER_COLUMN_UUID_G_UUID_2);
777                     }
778                 }
779 
780                 query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
781 
782                 query.append(BookmarksFolderModelImpl.ORDER_BY_JPQL);
783 
784                 String sql = query.toString();
785 
786                 Query q = session.createQuery(sql);
787 
788                 QueryPos qPos = QueryPos.getInstance(q);
789 
790                 if (uuid != null) {
791                     qPos.add(uuid);
792                 }
793 
794                 qPos.add(groupId);
795 
796                 List<BookmarksFolder> list = q.list();
797 
798                 result = list;
799 
800                 BookmarksFolder bookmarksFolder = null;
801 
802                 if (list.isEmpty()) {
803                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
804                         finderArgs, list);
805                 }
806                 else {
807                     bookmarksFolder = list.get(0);
808 
809                     cacheResult(bookmarksFolder);
810 
811                     if ((bookmarksFolder.getUuid() == null) ||
812                             !bookmarksFolder.getUuid().equals(uuid) ||
813                             (bookmarksFolder.getGroupId() != groupId)) {
814                         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
815                             finderArgs, bookmarksFolder);
816                     }
817                 }
818 
819                 return bookmarksFolder;
820             }
821             catch (Exception e) {
822                 throw processException(e);
823             }
824             finally {
825                 if (result == null) {
826                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
827                         finderArgs, new ArrayList<BookmarksFolder>());
828                 }
829 
830                 closeSession(session);
831             }
832         }
833         else {
834             if (result instanceof List<?>) {
835                 return null;
836             }
837             else {
838                 return (BookmarksFolder)result;
839             }
840         }
841     }
842 
843     public List<BookmarksFolder> findByGroupId(long groupId)
844         throws SystemException {
845         Object[] finderArgs = new Object[] { new Long(groupId) };
846 
847         List<BookmarksFolder> list = (List<BookmarksFolder>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_GROUPID,
848                 finderArgs, this);
849 
850         if (list == null) {
851             Session session = null;
852 
853             try {
854                 session = openSession();
855 
856                 StringBundler query = new StringBundler(3);
857 
858                 query.append(_SQL_SELECT_BOOKMARKSFOLDER_WHERE);
859 
860                 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
861 
862                 query.append(BookmarksFolderModelImpl.ORDER_BY_JPQL);
863 
864                 String sql = query.toString();
865 
866                 Query q = session.createQuery(sql);
867 
868                 QueryPos qPos = QueryPos.getInstance(q);
869 
870                 qPos.add(groupId);
871 
872                 list = q.list();
873             }
874             catch (Exception e) {
875                 throw processException(e);
876             }
877             finally {
878                 if (list == null) {
879                     list = new ArrayList<BookmarksFolder>();
880                 }
881 
882                 cacheResult(list);
883 
884                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_GROUPID,
885                     finderArgs, list);
886 
887                 closeSession(session);
888             }
889         }
890 
891         return list;
892     }
893 
894     public List<BookmarksFolder> findByGroupId(long groupId, int start, int end)
895         throws SystemException {
896         return findByGroupId(groupId, start, end, null);
897     }
898 
899     public List<BookmarksFolder> findByGroupId(long groupId, int start,
900         int end, OrderByComparator obc) throws SystemException {
901         Object[] finderArgs = new Object[] {
902                 new Long(groupId),
903                 
904                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
905             };
906 
907         List<BookmarksFolder> list = (List<BookmarksFolder>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_GROUPID,
908                 finderArgs, this);
909 
910         if (list == null) {
911             Session session = null;
912 
913             try {
914                 session = openSession();
915 
916                 StringBundler query = null;
917 
918                 if (obc != null) {
919                     query = new StringBundler(3 +
920                             (obc.getOrderByFields().length * 3));
921                 }
922                 else {
923                     query = new StringBundler(3);
924                 }
925 
926                 query.append(_SQL_SELECT_BOOKMARKSFOLDER_WHERE);
927 
928                 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
929 
930                 if (obc != null) {
931                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
932                 }
933 
934                 else {
935                     query.append(BookmarksFolderModelImpl.ORDER_BY_JPQL);
936                 }
937 
938                 String sql = query.toString();
939 
940                 Query q = session.createQuery(sql);
941 
942                 QueryPos qPos = QueryPos.getInstance(q);
943 
944                 qPos.add(groupId);
945 
946                 list = (List<BookmarksFolder>)QueryUtil.list(q, getDialect(),
947                         start, end);
948             }
949             catch (Exception e) {
950                 throw processException(e);
951             }
952             finally {
953                 if (list == null) {
954                     list = new ArrayList<BookmarksFolder>();
955                 }
956 
957                 cacheResult(list);
958 
959                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_GROUPID,
960                     finderArgs, list);
961 
962                 closeSession(session);
963             }
964         }
965 
966         return list;
967     }
968 
969     public BookmarksFolder findByGroupId_First(long groupId,
970         OrderByComparator obc) throws NoSuchFolderException, SystemException {
971         List<BookmarksFolder> list = findByGroupId(groupId, 0, 1, obc);
972 
973         if (list.isEmpty()) {
974             StringBundler msg = new StringBundler(4);
975 
976             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
977 
978             msg.append("groupId=");
979             msg.append(groupId);
980 
981             msg.append(StringPool.CLOSE_CURLY_BRACE);
982 
983             throw new NoSuchFolderException(msg.toString());
984         }
985         else {
986             return list.get(0);
987         }
988     }
989 
990     public BookmarksFolder findByGroupId_Last(long groupId,
991         OrderByComparator obc) throws NoSuchFolderException, SystemException {
992         int count = countByGroupId(groupId);
993 
994         List<BookmarksFolder> list = findByGroupId(groupId, count - 1, count,
995                 obc);
996 
997         if (list.isEmpty()) {
998             StringBundler msg = new StringBundler(4);
999 
1000            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1001
1002            msg.append("groupId=");
1003            msg.append(groupId);
1004
1005            msg.append(StringPool.CLOSE_CURLY_BRACE);
1006
1007            throw new NoSuchFolderException(msg.toString());
1008        }
1009        else {
1010            return list.get(0);
1011        }
1012    }
1013
1014    public BookmarksFolder[] findByGroupId_PrevAndNext(long folderId,
1015        long groupId, OrderByComparator obc)
1016        throws NoSuchFolderException, SystemException {
1017        BookmarksFolder bookmarksFolder = findByPrimaryKey(folderId);
1018
1019        int count = countByGroupId(groupId);
1020
1021        Session session = null;
1022
1023        try {
1024            session = openSession();
1025
1026            StringBundler query = null;
1027
1028            if (obc != null) {
1029                query = new StringBundler(3 +
1030                        (obc.getOrderByFields().length * 3));
1031            }
1032            else {
1033                query = new StringBundler(3);
1034            }
1035
1036            query.append(_SQL_SELECT_BOOKMARKSFOLDER_WHERE);
1037
1038            query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1039
1040            if (obc != null) {
1041                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
1042            }
1043
1044            else {
1045                query.append(BookmarksFolderModelImpl.ORDER_BY_JPQL);
1046            }
1047
1048            String sql = query.toString();
1049
1050            Query q = session.createQuery(sql);
1051
1052            QueryPos qPos = QueryPos.getInstance(q);
1053
1054            qPos.add(groupId);
1055
1056            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1057                    bookmarksFolder);
1058
1059            BookmarksFolder[] array = new BookmarksFolderImpl[3];
1060
1061            array[0] = (BookmarksFolder)objArray[0];
1062            array[1] = (BookmarksFolder)objArray[1];
1063            array[2] = (BookmarksFolder)objArray[2];
1064
1065            return array;
1066        }
1067        catch (Exception e) {
1068            throw processException(e);
1069        }
1070        finally {
1071            closeSession(session);
1072        }
1073    }
1074
1075    public List<BookmarksFolder> findByCompanyId(long companyId)
1076        throws SystemException {
1077        Object[] finderArgs = new Object[] { new Long(companyId) };
1078
1079        List<BookmarksFolder> list = (List<BookmarksFolder>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_COMPANYID,
1080                finderArgs, this);
1081
1082        if (list == null) {
1083            Session session = null;
1084
1085            try {
1086                session = openSession();
1087
1088                StringBundler query = new StringBundler(3);
1089
1090                query.append(_SQL_SELECT_BOOKMARKSFOLDER_WHERE);
1091
1092                query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1093
1094                query.append(BookmarksFolderModelImpl.ORDER_BY_JPQL);
1095
1096                String sql = query.toString();
1097
1098                Query q = session.createQuery(sql);
1099
1100                QueryPos qPos = QueryPos.getInstance(q);
1101
1102                qPos.add(companyId);
1103
1104                list = q.list();
1105            }
1106            catch (Exception e) {
1107                throw processException(e);
1108            }
1109            finally {
1110                if (list == null) {
1111                    list = new ArrayList<BookmarksFolder>();
1112                }
1113
1114                cacheResult(list);
1115
1116                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_COMPANYID,
1117                    finderArgs, list);
1118
1119                closeSession(session);
1120            }
1121        }
1122
1123        return list;
1124    }
1125
1126    public List<BookmarksFolder> findByCompanyId(long companyId, int start,
1127        int end) throws SystemException {
1128        return findByCompanyId(companyId, start, end, null);
1129    }
1130
1131    public List<BookmarksFolder> findByCompanyId(long companyId, int start,
1132        int end, OrderByComparator obc) throws SystemException {
1133        Object[] finderArgs = new Object[] {
1134                new Long(companyId),
1135                
1136                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1137            };
1138
1139        List<BookmarksFolder> list = (List<BookmarksFolder>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_COMPANYID,
1140                finderArgs, this);
1141
1142        if (list == null) {
1143            Session session = null;
1144
1145            try {
1146                session = openSession();
1147
1148                StringBundler query = null;
1149
1150                if (obc != null) {
1151                    query = new StringBundler(3 +
1152                            (obc.getOrderByFields().length * 3));
1153                }
1154                else {
1155                    query = new StringBundler(3);
1156                }
1157
1158                query.append(_SQL_SELECT_BOOKMARKSFOLDER_WHERE);
1159
1160                query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1161
1162                if (obc != null) {
1163                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
1164                }
1165
1166                else {
1167                    query.append(BookmarksFolderModelImpl.ORDER_BY_JPQL);
1168                }
1169
1170                String sql = query.toString();
1171
1172                Query q = session.createQuery(sql);
1173
1174                QueryPos qPos = QueryPos.getInstance(q);
1175
1176                qPos.add(companyId);
1177
1178                list = (List<BookmarksFolder>)QueryUtil.list(q, getDialect(),
1179                        start, end);
1180            }
1181            catch (Exception e) {
1182                throw processException(e);
1183            }
1184            finally {
1185                if (list == null) {
1186                    list = new ArrayList<BookmarksFolder>();
1187                }
1188
1189                cacheResult(list);
1190
1191                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_COMPANYID,
1192                    finderArgs, list);
1193
1194                closeSession(session);
1195            }
1196        }
1197
1198        return list;
1199    }
1200
1201    public BookmarksFolder findByCompanyId_First(long companyId,
1202        OrderByComparator obc) throws NoSuchFolderException, SystemException {
1203        List<BookmarksFolder> list = findByCompanyId(companyId, 0, 1, obc);
1204
1205        if (list.isEmpty()) {
1206            StringBundler msg = new StringBundler(4);
1207
1208            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1209
1210            msg.append("companyId=");
1211            msg.append(companyId);
1212
1213            msg.append(StringPool.CLOSE_CURLY_BRACE);
1214
1215            throw new NoSuchFolderException(msg.toString());
1216        }
1217        else {
1218            return list.get(0);
1219        }
1220    }
1221
1222    public BookmarksFolder findByCompanyId_Last(long companyId,
1223        OrderByComparator obc) throws NoSuchFolderException, SystemException {
1224        int count = countByCompanyId(companyId);
1225
1226        List<BookmarksFolder> list = findByCompanyId(companyId, count - 1,
1227                count, obc);
1228
1229        if (list.isEmpty()) {
1230            StringBundler msg = new StringBundler(4);
1231
1232            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1233
1234            msg.append("companyId=");
1235            msg.append(companyId);
1236
1237            msg.append(StringPool.CLOSE_CURLY_BRACE);
1238
1239            throw new NoSuchFolderException(msg.toString());
1240        }
1241        else {
1242            return list.get(0);
1243        }
1244    }
1245
1246    public BookmarksFolder[] findByCompanyId_PrevAndNext(long folderId,
1247        long companyId, OrderByComparator obc)
1248        throws NoSuchFolderException, SystemException {
1249        BookmarksFolder bookmarksFolder = findByPrimaryKey(folderId);
1250
1251        int count = countByCompanyId(companyId);
1252
1253        Session session = null;
1254
1255        try {
1256            session = openSession();
1257
1258            StringBundler query = null;
1259
1260            if (obc != null) {
1261                query = new StringBundler(3 +
1262                        (obc.getOrderByFields().length * 3));
1263            }
1264            else {
1265                query = new StringBundler(3);
1266            }
1267
1268            query.append(_SQL_SELECT_BOOKMARKSFOLDER_WHERE);
1269
1270            query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1271
1272            if (obc != null) {
1273                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
1274            }
1275
1276            else {
1277                query.append(BookmarksFolderModelImpl.ORDER_BY_JPQL);
1278            }
1279
1280            String sql = query.toString();
1281
1282            Query q = session.createQuery(sql);
1283
1284            QueryPos qPos = QueryPos.getInstance(q);
1285
1286            qPos.add(companyId);
1287
1288            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1289                    bookmarksFolder);
1290
1291            BookmarksFolder[] array = new BookmarksFolderImpl[3];
1292
1293            array[0] = (BookmarksFolder)objArray[0];
1294            array[1] = (BookmarksFolder)objArray[1];
1295            array[2] = (BookmarksFolder)objArray[2];
1296
1297            return array;
1298        }
1299        catch (Exception e) {
1300            throw processException(e);
1301        }
1302        finally {
1303            closeSession(session);
1304        }
1305    }
1306
1307    public List<BookmarksFolder> findByG_P(long groupId, long parentFolderId)
1308        throws SystemException {
1309        Object[] finderArgs = new Object[] {
1310                new Long(groupId), new Long(parentFolderId)
1311            };
1312
1313        List<BookmarksFolder> list = (List<BookmarksFolder>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_P,
1314                finderArgs, this);
1315
1316        if (list == null) {
1317            Session session = null;
1318
1319            try {
1320                session = openSession();
1321
1322                StringBundler query = new StringBundler(4);
1323
1324                query.append(_SQL_SELECT_BOOKMARKSFOLDER_WHERE);
1325
1326                query.append(_FINDER_COLUMN_G_P_GROUPID_2);
1327
1328                query.append(_FINDER_COLUMN_G_P_PARENTFOLDERID_2);
1329
1330                query.append(BookmarksFolderModelImpl.ORDER_BY_JPQL);
1331
1332                String sql = query.toString();
1333
1334                Query q = session.createQuery(sql);
1335
1336                QueryPos qPos = QueryPos.getInstance(q);
1337
1338                qPos.add(groupId);
1339
1340                qPos.add(parentFolderId);
1341
1342                list = q.list();
1343            }
1344            catch (Exception e) {
1345                throw processException(e);
1346            }
1347            finally {
1348                if (list == null) {
1349                    list = new ArrayList<BookmarksFolder>();
1350                }
1351
1352                cacheResult(list);
1353
1354                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_P, finderArgs,
1355                    list);
1356
1357                closeSession(session);
1358            }
1359        }
1360
1361        return list;
1362    }
1363
1364    public List<BookmarksFolder> findByG_P(long groupId, long parentFolderId,
1365        int start, int end) throws SystemException {
1366        return findByG_P(groupId, parentFolderId, start, end, null);
1367    }
1368
1369    public List<BookmarksFolder> findByG_P(long groupId, long parentFolderId,
1370        int start, int end, OrderByComparator obc) throws SystemException {
1371        Object[] finderArgs = new Object[] {
1372                new Long(groupId), new Long(parentFolderId),
1373                
1374                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1375            };
1376
1377        List<BookmarksFolder> list = (List<BookmarksFolder>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_G_P,
1378                finderArgs, this);
1379
1380        if (list == null) {
1381            Session session = null;
1382
1383            try {
1384                session = openSession();
1385
1386                StringBundler query = null;
1387
1388                if (obc != null) {
1389                    query = new StringBundler(4 +
1390                            (obc.getOrderByFields().length * 3));
1391                }
1392                else {
1393                    query = new StringBundler(4);
1394                }
1395
1396                query.append(_SQL_SELECT_BOOKMARKSFOLDER_WHERE);
1397
1398                query.append(_FINDER_COLUMN_G_P_GROUPID_2);
1399
1400                query.append(_FINDER_COLUMN_G_P_PARENTFOLDERID_2);
1401
1402                if (obc != null) {
1403                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
1404                }
1405
1406                else {
1407                    query.append(BookmarksFolderModelImpl.ORDER_BY_JPQL);
1408                }
1409
1410                String sql = query.toString();
1411
1412                Query q = session.createQuery(sql);
1413
1414                QueryPos qPos = QueryPos.getInstance(q);
1415
1416                qPos.add(groupId);
1417
1418                qPos.add(parentFolderId);
1419
1420                list = (List<BookmarksFolder>)QueryUtil.list(q, getDialect(),
1421                        start, end);
1422            }
1423            catch (Exception e) {
1424                throw processException(e);
1425            }
1426            finally {
1427                if (list == null) {
1428                    list = new ArrayList<BookmarksFolder>();
1429                }
1430
1431                cacheResult(list);
1432
1433                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_G_P,
1434                    finderArgs, list);
1435
1436                closeSession(session);
1437            }
1438        }
1439
1440        return list;
1441    }
1442
1443    public BookmarksFolder findByG_P_First(long groupId, long parentFolderId,
1444        OrderByComparator obc) throws NoSuchFolderException, SystemException {
1445        List<BookmarksFolder> list = findByG_P(groupId, parentFolderId, 0, 1,
1446                obc);
1447
1448        if (list.isEmpty()) {
1449            StringBundler msg = new StringBundler(6);
1450
1451            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1452
1453            msg.append("groupId=");
1454            msg.append(groupId);
1455
1456            msg.append(", parentFolderId=");
1457            msg.append(parentFolderId);
1458
1459            msg.append(StringPool.CLOSE_CURLY_BRACE);
1460
1461            throw new NoSuchFolderException(msg.toString());
1462        }
1463        else {
1464            return list.get(0);
1465        }
1466    }
1467
1468    public BookmarksFolder findByG_P_Last(long groupId, long parentFolderId,
1469        OrderByComparator obc) throws NoSuchFolderException, SystemException {
1470        int count = countByG_P(groupId, parentFolderId);
1471
1472        List<BookmarksFolder> list = findByG_P(groupId, parentFolderId,
1473                count - 1, count, obc);
1474
1475        if (list.isEmpty()) {
1476            StringBundler msg = new StringBundler(6);
1477
1478            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1479
1480            msg.append("groupId=");
1481            msg.append(groupId);
1482
1483            msg.append(", parentFolderId=");
1484            msg.append(parentFolderId);
1485
1486            msg.append(StringPool.CLOSE_CURLY_BRACE);
1487
1488            throw new NoSuchFolderException(msg.toString());
1489        }
1490        else {
1491            return list.get(0);
1492        }
1493    }
1494
1495    public BookmarksFolder[] findByG_P_PrevAndNext(long folderId, long groupId,
1496        long parentFolderId, OrderByComparator obc)
1497        throws NoSuchFolderException, SystemException {
1498        BookmarksFolder bookmarksFolder = findByPrimaryKey(folderId);
1499
1500        int count = countByG_P(groupId, parentFolderId);
1501
1502        Session session = null;
1503
1504        try {
1505            session = openSession();
1506
1507            StringBundler query = null;
1508
1509            if (obc != null) {
1510                query = new StringBundler(4 +
1511                        (obc.getOrderByFields().length * 3));
1512            }
1513            else {
1514                query = new StringBundler(4);
1515            }
1516
1517            query.append(_SQL_SELECT_BOOKMARKSFOLDER_WHERE);
1518
1519            query.append(_FINDER_COLUMN_G_P_GROUPID_2);
1520
1521            query.append(_FINDER_COLUMN_G_P_PARENTFOLDERID_2);
1522
1523            if (obc != null) {
1524                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
1525            }
1526
1527            else {
1528                query.append(BookmarksFolderModelImpl.ORDER_BY_JPQL);
1529            }
1530
1531            String sql = query.toString();
1532
1533            Query q = session.createQuery(sql);
1534
1535            QueryPos qPos = QueryPos.getInstance(q);
1536
1537            qPos.add(groupId);
1538
1539            qPos.add(parentFolderId);
1540
1541            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1542                    bookmarksFolder);
1543
1544            BookmarksFolder[] array = new BookmarksFolderImpl[3];
1545
1546            array[0] = (BookmarksFolder)objArray[0];
1547            array[1] = (BookmarksFolder)objArray[1];
1548            array[2] = (BookmarksFolder)objArray[2];
1549
1550            return array;
1551        }
1552        catch (Exception e) {
1553            throw processException(e);
1554        }
1555        finally {
1556            closeSession(session);
1557        }
1558    }
1559
1560    public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery)
1561        throws SystemException {
1562        Session session = null;
1563
1564        try {
1565            session = openSession();
1566
1567            dynamicQuery.compile(session);
1568
1569            return dynamicQuery.list();
1570        }
1571        catch (Exception e) {
1572            throw processException(e);
1573        }
1574        finally {
1575            closeSession(session);
1576        }
1577    }
1578
1579    public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery,
1580        int start, int end) throws SystemException {
1581        Session session = null;
1582
1583        try {
1584            session = openSession();
1585
1586            dynamicQuery.setLimit(start, end);
1587
1588            dynamicQuery.compile(session);
1589
1590            return dynamicQuery.list();
1591        }
1592        catch (Exception e) {
1593            throw processException(e);
1594        }
1595        finally {
1596            closeSession(session);
1597        }
1598    }
1599
1600    public List<BookmarksFolder> findAll() throws SystemException {
1601        return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1602    }
1603
1604    public List<BookmarksFolder> findAll(int start, int end)
1605        throws SystemException {
1606        return findAll(start, end, null);
1607    }
1608
1609    public List<BookmarksFolder> findAll(int start, int end,
1610        OrderByComparator obc) throws SystemException {
1611        Object[] finderArgs = new Object[] {
1612                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1613            };
1614
1615        List<BookmarksFolder> list = (List<BookmarksFolder>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
1616                finderArgs, this);
1617
1618        if (list == null) {
1619            Session session = null;
1620
1621            try {
1622                session = openSession();
1623
1624                StringBundler query = null;
1625                String sql = null;
1626
1627                if (obc != null) {
1628                    query = new StringBundler(2 +
1629                            (obc.getOrderByFields().length * 3));
1630
1631                    query.append(_SQL_SELECT_BOOKMARKSFOLDER);
1632
1633                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
1634
1635                    sql = query.toString();
1636                }
1637
1638                else {
1639                    sql = _SQL_SELECT_BOOKMARKSFOLDER.concat(BookmarksFolderModelImpl.ORDER_BY_JPQL);
1640                }
1641
1642                Query q = session.createQuery(sql);
1643
1644                if (obc == null) {
1645                    list = (List<BookmarksFolder>)QueryUtil.list(q,
1646                            getDialect(), start, end, false);
1647
1648                    Collections.sort(list);
1649                }
1650                else {
1651                    list = (List<BookmarksFolder>)QueryUtil.list(q,
1652                            getDialect(), start, end);
1653                }
1654            }
1655            catch (Exception e) {
1656                throw processException(e);
1657            }
1658            finally {
1659                if (list == null) {
1660                    list = new ArrayList<BookmarksFolder>();
1661                }
1662
1663                cacheResult(list);
1664
1665                FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
1666
1667                closeSession(session);
1668            }
1669        }
1670
1671        return list;
1672    }
1673
1674    public void removeByUuid(String uuid) throws SystemException {
1675        for (BookmarksFolder bookmarksFolder : findByUuid(uuid)) {
1676            remove(bookmarksFolder);
1677        }
1678    }
1679
1680    public void removeByUUID_G(String uuid, long groupId)
1681        throws NoSuchFolderException, SystemException {
1682        BookmarksFolder bookmarksFolder = findByUUID_G(uuid, groupId);
1683
1684        remove(bookmarksFolder);
1685    }
1686
1687    public void removeByGroupId(long groupId) throws SystemException {
1688        for (BookmarksFolder bookmarksFolder : findByGroupId(groupId)) {
1689            remove(bookmarksFolder);
1690        }
1691    }
1692
1693    public void removeByCompanyId(long companyId) throws SystemException {
1694        for (BookmarksFolder bookmarksFolder : findByCompanyId(companyId)) {
1695            remove(bookmarksFolder);
1696        }
1697    }
1698
1699    public void removeByG_P(long groupId, long parentFolderId)
1700        throws SystemException {
1701        for (BookmarksFolder bookmarksFolder : findByG_P(groupId, parentFolderId)) {
1702            remove(bookmarksFolder);
1703        }
1704    }
1705
1706    public void removeAll() throws SystemException {
1707        for (BookmarksFolder bookmarksFolder : findAll()) {
1708            remove(bookmarksFolder);
1709        }
1710    }
1711
1712    public int countByUuid(String uuid) throws SystemException {
1713        Object[] finderArgs = new Object[] { uuid };
1714
1715        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID,
1716                finderArgs, this);
1717
1718        if (count == null) {
1719            Session session = null;
1720
1721            try {
1722                session = openSession();
1723
1724                StringBundler query = new StringBundler(2);
1725
1726                query.append(_SQL_COUNT_BOOKMARKSFOLDER_WHERE);
1727
1728                if (uuid == null) {
1729                    query.append(_FINDER_COLUMN_UUID_UUID_1);
1730                }
1731                else {
1732                    if (uuid.equals(StringPool.BLANK)) {
1733                        query.append(_FINDER_COLUMN_UUID_UUID_3);
1734                    }
1735                    else {
1736                        query.append(_FINDER_COLUMN_UUID_UUID_2);
1737                    }
1738                }
1739
1740                String sql = query.toString();
1741
1742                Query q = session.createQuery(sql);
1743
1744                QueryPos qPos = QueryPos.getInstance(q);
1745
1746                if (uuid != null) {
1747                    qPos.add(uuid);
1748                }
1749
1750                count = (Long)q.uniqueResult();
1751            }
1752            catch (Exception e) {
1753                throw processException(e);
1754            }
1755            finally {
1756                if (count == null) {
1757                    count = Long.valueOf(0);
1758                }
1759
1760                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID,
1761                    finderArgs, count);
1762
1763                closeSession(session);
1764            }
1765        }
1766
1767        return count.intValue();
1768    }
1769
1770    public int countByUUID_G(String uuid, long groupId)
1771        throws SystemException {
1772        Object[] finderArgs = new Object[] { uuid, new Long(groupId) };
1773
1774        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID_G,
1775                finderArgs, this);
1776
1777        if (count == null) {
1778            Session session = null;
1779
1780            try {
1781                session = openSession();
1782
1783                StringBundler query = new StringBundler(3);
1784
1785                query.append(_SQL_COUNT_BOOKMARKSFOLDER_WHERE);
1786
1787                if (uuid == null) {
1788                    query.append(_FINDER_COLUMN_UUID_G_UUID_1);
1789                }
1790                else {
1791                    if (uuid.equals(StringPool.BLANK)) {
1792                        query.append(_FINDER_COLUMN_UUID_G_UUID_3);
1793                    }
1794                    else {
1795                        query.append(_FINDER_COLUMN_UUID_G_UUID_2);
1796                    }
1797                }
1798
1799                query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
1800
1801                String sql = query.toString();
1802
1803                Query q = session.createQuery(sql);
1804
1805                QueryPos qPos = QueryPos.getInstance(q);
1806
1807                if (uuid != null) {
1808                    qPos.add(uuid);
1809                }
1810
1811                qPos.add(groupId);
1812
1813                count = (Long)q.uniqueResult();
1814            }
1815            catch (Exception e) {
1816                throw processException(e);
1817            }
1818            finally {
1819                if (count == null) {
1820                    count = Long.valueOf(0);
1821                }
1822
1823                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID_G,
1824                    finderArgs, count);
1825
1826                closeSession(session);
1827            }
1828        }
1829
1830        return count.intValue();
1831    }
1832
1833    public int countByGroupId(long groupId) throws SystemException {
1834        Object[] finderArgs = new Object[] { new Long(groupId) };
1835
1836        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_GROUPID,
1837                finderArgs, this);
1838
1839        if (count == null) {
1840            Session session = null;
1841
1842            try {
1843                session = openSession();
1844
1845                StringBundler query = new StringBundler(2);
1846
1847                query.append(_SQL_COUNT_BOOKMARKSFOLDER_WHERE);
1848
1849                query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1850
1851                String sql = query.toString();
1852
1853                Query q = session.createQuery(sql);
1854
1855                QueryPos qPos = QueryPos.getInstance(q);
1856
1857                qPos.add(groupId);
1858
1859                count = (Long)q.uniqueResult();
1860            }
1861            catch (Exception e) {
1862                throw processException(e);
1863            }
1864            finally {
1865                if (count == null) {
1866                    count = Long.valueOf(0);
1867                }
1868
1869                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_GROUPID,
1870                    finderArgs, count);
1871
1872                closeSession(session);
1873            }
1874        }
1875
1876        return count.intValue();
1877    }
1878
1879    public int countByCompanyId(long companyId) throws SystemException {
1880        Object[] finderArgs = new Object[] { new Long(companyId) };
1881
1882        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_COMPANYID,
1883                finderArgs, this);
1884
1885        if (count == null) {
1886            Session session = null;
1887
1888            try {
1889                session = openSession();
1890
1891                StringBundler query = new StringBundler(2);
1892
1893                query.append(_SQL_COUNT_BOOKMARKSFOLDER_WHERE);
1894
1895                query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1896
1897                String sql = query.toString();
1898
1899                Query q = session.createQuery(sql);
1900
1901                QueryPos qPos = QueryPos.getInstance(q);
1902
1903                qPos.add(companyId);
1904
1905                count = (Long)q.uniqueResult();
1906            }
1907            catch (Exception e) {
1908                throw processException(e);
1909            }
1910            finally {
1911                if (count == null) {
1912                    count = Long.valueOf(0);
1913                }
1914
1915                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_COMPANYID,
1916                    finderArgs, count);
1917
1918                closeSession(session);
1919            }
1920        }
1921
1922        return count.intValue();
1923    }
1924
1925    public int countByG_P(long groupId, long parentFolderId)
1926        throws SystemException {
1927        Object[] finderArgs = new Object[] {
1928                new Long(groupId), new Long(parentFolderId)
1929            };
1930
1931        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_P,
1932                finderArgs, this);
1933
1934        if (count == null) {
1935            Session session = null;
1936
1937            try {
1938                session = openSession();
1939
1940                StringBundler query = new StringBundler(3);
1941
1942                query.append(_SQL_COUNT_BOOKMARKSFOLDER_WHERE);
1943
1944                query.append(_FINDER_COLUMN_G_P_GROUPID_2);
1945
1946                query.append(_FINDER_COLUMN_G_P_PARENTFOLDERID_2);
1947
1948                String sql = query.toString();
1949
1950                Query q = session.createQuery(sql);
1951
1952                QueryPos qPos = QueryPos.getInstance(q);
1953
1954                qPos.add(groupId);
1955
1956                qPos.add(parentFolderId);
1957
1958                count = (Long)q.uniqueResult();
1959            }
1960            catch (Exception e) {
1961                throw processException(e);
1962            }
1963            finally {
1964                if (count == null) {
1965                    count = Long.valueOf(0);
1966                }
1967
1968                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_P, finderArgs,
1969                    count);
1970
1971                closeSession(session);
1972            }
1973        }
1974
1975        return count.intValue();
1976    }
1977
1978    public int countAll() throws SystemException {
1979        Object[] finderArgs = new Object[0];
1980
1981        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
1982                finderArgs, this);
1983
1984        if (count == null) {
1985            Session session = null;
1986
1987            try {
1988                session = openSession();
1989
1990                Query q = session.createQuery(_SQL_COUNT_BOOKMARKSFOLDER);
1991
1992                count = (Long)q.uniqueResult();
1993            }
1994            catch (Exception e) {
1995                throw processException(e);
1996            }
1997            finally {
1998                if (count == null) {
1999                    count = Long.valueOf(0);
2000                }
2001
2002                FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
2003                    count);
2004
2005                closeSession(session);
2006            }
2007        }
2008
2009        return count.intValue();
2010    }
2011
2012    public void afterPropertiesSet() {
2013        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
2014                    com.liferay.portal.util.PropsUtil.get(
2015                        "value.object.listener.com.liferay.portlet.bookmarks.model.BookmarksFolder")));
2016
2017        if (listenerClassNames.length > 0) {
2018            try {
2019                List<ModelListener<BookmarksFolder>> listenersList = new ArrayList<ModelListener<BookmarksFolder>>();
2020
2021                for (String listenerClassName : listenerClassNames) {
2022                    listenersList.add((ModelListener<BookmarksFolder>)Class.forName(
2023                            listenerClassName).newInstance());
2024                }
2025
2026                listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
2027            }
2028            catch (Exception e) {
2029                _log.error(e);
2030            }
2031        }
2032    }
2033
2034    @BeanReference(name = "com.liferay.portlet.bookmarks.service.persistence.BookmarksEntryPersistence")
2035    protected com.liferay.portlet.bookmarks.service.persistence.BookmarksEntryPersistence bookmarksEntryPersistence;
2036    @BeanReference(name = "com.liferay.portlet.bookmarks.service.persistence.BookmarksFolderPersistence")
2037    protected com.liferay.portlet.bookmarks.service.persistence.BookmarksFolderPersistence bookmarksFolderPersistence;
2038    @BeanReference(name = "com.liferay.portal.service.persistence.ResourcePersistence")
2039    protected com.liferay.portal.service.persistence.ResourcePersistence resourcePersistence;
2040    @BeanReference(name = "com.liferay.portal.service.persistence.UserPersistence")
2041    protected com.liferay.portal.service.persistence.UserPersistence userPersistence;
2042    private static final String _SQL_SELECT_BOOKMARKSFOLDER = "SELECT bookmarksFolder FROM BookmarksFolder bookmarksFolder";
2043    private static final String _SQL_SELECT_BOOKMARKSFOLDER_WHERE = "SELECT bookmarksFolder FROM BookmarksFolder bookmarksFolder WHERE ";
2044    private static final String _SQL_COUNT_BOOKMARKSFOLDER = "SELECT COUNT(bookmarksFolder) FROM BookmarksFolder bookmarksFolder";
2045    private static final String _SQL_COUNT_BOOKMARKSFOLDER_WHERE = "SELECT COUNT(bookmarksFolder) FROM BookmarksFolder bookmarksFolder WHERE ";
2046    private static final String _FINDER_COLUMN_UUID_UUID_1 = "bookmarksFolder.uuid IS NULL";
2047    private static final String _FINDER_COLUMN_UUID_UUID_2 = "bookmarksFolder.uuid = ?";
2048    private static final String _FINDER_COLUMN_UUID_UUID_3 = "(bookmarksFolder.uuid IS NULL OR bookmarksFolder.uuid = ?)";
2049    private static final String _FINDER_COLUMN_UUID_G_UUID_1 = "bookmarksFolder.uuid IS NULL AND ";
2050    private static final String _FINDER_COLUMN_UUID_G_UUID_2 = "bookmarksFolder.uuid = ? AND ";
2051    private static final String _FINDER_COLUMN_UUID_G_UUID_3 = "(bookmarksFolder.uuid IS NULL OR bookmarksFolder.uuid = ?) AND ";
2052    private static final String _FINDER_COLUMN_UUID_G_GROUPID_2 = "bookmarksFolder.groupId = ?";
2053    private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "bookmarksFolder.groupId = ?";
2054    private static final String _FINDER_COLUMN_COMPANYID_COMPANYID_2 = "bookmarksFolder.companyId = ?";
2055    private static final String _FINDER_COLUMN_G_P_GROUPID_2 = "bookmarksFolder.groupId = ? AND ";
2056    private static final String _FINDER_COLUMN_G_P_PARENTFOLDERID_2 = "bookmarksFolder.parentFolderId = ?";
2057    private static final String _ORDER_BY_ENTITY_ALIAS = "bookmarksFolder.";
2058    private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No BookmarksFolder exists with the primary key ";
2059    private static final String _NO_SUCH_ENTITY_WITH_KEY = "No BookmarksFolder exists with the key {";
2060    private static Log _log = LogFactoryUtil.getLog(BookmarksFolderPersistenceImpl.class);
2061}