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