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