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