001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.bookmarks.service.persistence;
016    
017    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
018    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
019    import com.liferay.portal.kernel.exception.SystemException;
020    import com.liferay.portal.kernel.util.OrderByComparator;
021    import com.liferay.portal.kernel.util.ReferenceRegistry;
022    import com.liferay.portal.service.ServiceContext;
023    
024    import com.liferay.portlet.bookmarks.model.BookmarksEntry;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the bookmarks entry service. This utility wraps {@link BookmarksEntryPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
030     *
031     * <p>
032     * Caching information and settings can be found in <code>portal.properties</code>
033     * </p>
034     *
035     * @author Brian Wing Shun Chan
036     * @see BookmarksEntryPersistence
037     * @see BookmarksEntryPersistenceImpl
038     * @generated
039     */
040    public class BookmarksEntryUtil {
041            /*
042             * NOTE FOR DEVELOPERS:
043             *
044             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
045             */
046    
047            /**
048             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
049             */
050            public static void clearCache() {
051                    getPersistence().clearCache();
052            }
053    
054            /**
055             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
056             */
057            public static void clearCache(BookmarksEntry bookmarksEntry) {
058                    getPersistence().clearCache(bookmarksEntry);
059            }
060    
061            /**
062             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
063             */
064            public long countWithDynamicQuery(DynamicQuery dynamicQuery)
065                    throws SystemException {
066                    return getPersistence().countWithDynamicQuery(dynamicQuery);
067            }
068    
069            /**
070             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
071             */
072            public static List<BookmarksEntry> findWithDynamicQuery(
073                    DynamicQuery dynamicQuery) throws SystemException {
074                    return getPersistence().findWithDynamicQuery(dynamicQuery);
075            }
076    
077            /**
078             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
079             */
080            public static List<BookmarksEntry> findWithDynamicQuery(
081                    DynamicQuery dynamicQuery, int start, int end)
082                    throws SystemException {
083                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
084            }
085    
086            /**
087             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
088             */
089            public static List<BookmarksEntry> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator orderByComparator) throws SystemException {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
099             */
100            public static BookmarksEntry update(BookmarksEntry bookmarksEntry)
101                    throws SystemException {
102                    return getPersistence().update(bookmarksEntry);
103            }
104    
105            /**
106             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
107             */
108            public static BookmarksEntry update(BookmarksEntry bookmarksEntry,
109                    ServiceContext serviceContext) throws SystemException {
110                    return getPersistence().update(bookmarksEntry, serviceContext);
111            }
112    
113            /**
114            * Returns all the bookmarks entries where resourceBlockId = &#63;.
115            *
116            * @param resourceBlockId the resource block ID
117            * @return the matching bookmarks entries
118            * @throws SystemException if a system exception occurred
119            */
120            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByResourceBlockId(
121                    long resourceBlockId)
122                    throws com.liferay.portal.kernel.exception.SystemException {
123                    return getPersistence().findByResourceBlockId(resourceBlockId);
124            }
125    
126            /**
127            * Returns a range of all the bookmarks entries where resourceBlockId = &#63;.
128            *
129            * <p>
130            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
131            * </p>
132            *
133            * @param resourceBlockId the resource block ID
134            * @param start the lower bound of the range of bookmarks entries
135            * @param end the upper bound of the range of bookmarks entries (not inclusive)
136            * @return the range of matching bookmarks entries
137            * @throws SystemException if a system exception occurred
138            */
139            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByResourceBlockId(
140                    long resourceBlockId, int start, int end)
141                    throws com.liferay.portal.kernel.exception.SystemException {
142                    return getPersistence()
143                                       .findByResourceBlockId(resourceBlockId, start, end);
144            }
145    
146            /**
147            * Returns an ordered range of all the bookmarks entries where resourceBlockId = &#63;.
148            *
149            * <p>
150            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
151            * </p>
152            *
153            * @param resourceBlockId the resource block ID
154            * @param start the lower bound of the range of bookmarks entries
155            * @param end the upper bound of the range of bookmarks entries (not inclusive)
156            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
157            * @return the ordered range of matching bookmarks entries
158            * @throws SystemException if a system exception occurred
159            */
160            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByResourceBlockId(
161                    long resourceBlockId, int start, int end,
162                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
163                    throws com.liferay.portal.kernel.exception.SystemException {
164                    return getPersistence()
165                                       .findByResourceBlockId(resourceBlockId, start, end,
166                            orderByComparator);
167            }
168    
169            /**
170            * Returns the first bookmarks entry in the ordered set where resourceBlockId = &#63;.
171            *
172            * @param resourceBlockId the resource block ID
173            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
174            * @return the first matching bookmarks entry
175            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
176            * @throws SystemException if a system exception occurred
177            */
178            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByResourceBlockId_First(
179                    long resourceBlockId,
180                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
181                    throws com.liferay.portal.kernel.exception.SystemException,
182                            com.liferay.portlet.bookmarks.NoSuchEntryException {
183                    return getPersistence()
184                                       .findByResourceBlockId_First(resourceBlockId,
185                            orderByComparator);
186            }
187    
188            /**
189            * Returns the first bookmarks entry in the ordered set where resourceBlockId = &#63;.
190            *
191            * @param resourceBlockId the resource block ID
192            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
193            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
194            * @throws SystemException if a system exception occurred
195            */
196            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByResourceBlockId_First(
197                    long resourceBlockId,
198                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
199                    throws com.liferay.portal.kernel.exception.SystemException {
200                    return getPersistence()
201                                       .fetchByResourceBlockId_First(resourceBlockId,
202                            orderByComparator);
203            }
204    
205            /**
206            * Returns the last bookmarks entry in the ordered set where resourceBlockId = &#63;.
207            *
208            * @param resourceBlockId the resource block ID
209            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
210            * @return the last matching bookmarks entry
211            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
212            * @throws SystemException if a system exception occurred
213            */
214            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByResourceBlockId_Last(
215                    long resourceBlockId,
216                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
217                    throws com.liferay.portal.kernel.exception.SystemException,
218                            com.liferay.portlet.bookmarks.NoSuchEntryException {
219                    return getPersistence()
220                                       .findByResourceBlockId_Last(resourceBlockId,
221                            orderByComparator);
222            }
223    
224            /**
225            * Returns the last bookmarks entry in the ordered set where resourceBlockId = &#63;.
226            *
227            * @param resourceBlockId the resource block ID
228            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
229            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
230            * @throws SystemException if a system exception occurred
231            */
232            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByResourceBlockId_Last(
233                    long resourceBlockId,
234                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
235                    throws com.liferay.portal.kernel.exception.SystemException {
236                    return getPersistence()
237                                       .fetchByResourceBlockId_Last(resourceBlockId,
238                            orderByComparator);
239            }
240    
241            /**
242            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where resourceBlockId = &#63;.
243            *
244            * @param entryId the primary key of the current bookmarks entry
245            * @param resourceBlockId the resource block ID
246            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
247            * @return the previous, current, and next bookmarks entry
248            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
249            * @throws SystemException if a system exception occurred
250            */
251            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByResourceBlockId_PrevAndNext(
252                    long entryId, long resourceBlockId,
253                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
254                    throws com.liferay.portal.kernel.exception.SystemException,
255                            com.liferay.portlet.bookmarks.NoSuchEntryException {
256                    return getPersistence()
257                                       .findByResourceBlockId_PrevAndNext(entryId, resourceBlockId,
258                            orderByComparator);
259            }
260    
261            /**
262            * Removes all the bookmarks entries where resourceBlockId = &#63; from the database.
263            *
264            * @param resourceBlockId the resource block ID
265            * @throws SystemException if a system exception occurred
266            */
267            public static void removeByResourceBlockId(long resourceBlockId)
268                    throws com.liferay.portal.kernel.exception.SystemException {
269                    getPersistence().removeByResourceBlockId(resourceBlockId);
270            }
271    
272            /**
273            * Returns the number of bookmarks entries where resourceBlockId = &#63;.
274            *
275            * @param resourceBlockId the resource block ID
276            * @return the number of matching bookmarks entries
277            * @throws SystemException if a system exception occurred
278            */
279            public static int countByResourceBlockId(long resourceBlockId)
280                    throws com.liferay.portal.kernel.exception.SystemException {
281                    return getPersistence().countByResourceBlockId(resourceBlockId);
282            }
283    
284            /**
285            * Returns all the bookmarks entries where uuid = &#63;.
286            *
287            * @param uuid the uuid
288            * @return the matching bookmarks entries
289            * @throws SystemException if a system exception occurred
290            */
291            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid(
292                    java.lang.String uuid)
293                    throws com.liferay.portal.kernel.exception.SystemException {
294                    return getPersistence().findByUuid(uuid);
295            }
296    
297            /**
298            * Returns a range of all the bookmarks entries where uuid = &#63;.
299            *
300            * <p>
301            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
302            * </p>
303            *
304            * @param uuid the uuid
305            * @param start the lower bound of the range of bookmarks entries
306            * @param end the upper bound of the range of bookmarks entries (not inclusive)
307            * @return the range of matching bookmarks entries
308            * @throws SystemException if a system exception occurred
309            */
310            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid(
311                    java.lang.String uuid, int start, int end)
312                    throws com.liferay.portal.kernel.exception.SystemException {
313                    return getPersistence().findByUuid(uuid, start, end);
314            }
315    
316            /**
317            * Returns an ordered range of all the bookmarks entries where uuid = &#63;.
318            *
319            * <p>
320            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
321            * </p>
322            *
323            * @param uuid the uuid
324            * @param start the lower bound of the range of bookmarks entries
325            * @param end the upper bound of the range of bookmarks entries (not inclusive)
326            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
327            * @return the ordered range of matching bookmarks entries
328            * @throws SystemException if a system exception occurred
329            */
330            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid(
331                    java.lang.String uuid, int start, int end,
332                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
333                    throws com.liferay.portal.kernel.exception.SystemException {
334                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
335            }
336    
337            /**
338            * Returns the first bookmarks entry in the ordered set where uuid = &#63;.
339            *
340            * @param uuid the uuid
341            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
342            * @return the first matching bookmarks entry
343            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
344            * @throws SystemException if a system exception occurred
345            */
346            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_First(
347                    java.lang.String uuid,
348                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
349                    throws com.liferay.portal.kernel.exception.SystemException,
350                            com.liferay.portlet.bookmarks.NoSuchEntryException {
351                    return getPersistence().findByUuid_First(uuid, orderByComparator);
352            }
353    
354            /**
355            * Returns the first bookmarks entry in the ordered set where uuid = &#63;.
356            *
357            * @param uuid the uuid
358            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
359            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
360            * @throws SystemException if a system exception occurred
361            */
362            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_First(
363                    java.lang.String uuid,
364                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
365                    throws com.liferay.portal.kernel.exception.SystemException {
366                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
367            }
368    
369            /**
370            * Returns the last bookmarks entry in the ordered set where uuid = &#63;.
371            *
372            * @param uuid the uuid
373            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
374            * @return the last matching bookmarks entry
375            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
376            * @throws SystemException if a system exception occurred
377            */
378            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_Last(
379                    java.lang.String uuid,
380                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
381                    throws com.liferay.portal.kernel.exception.SystemException,
382                            com.liferay.portlet.bookmarks.NoSuchEntryException {
383                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
384            }
385    
386            /**
387            * Returns the last bookmarks entry in the ordered set where uuid = &#63;.
388            *
389            * @param uuid the uuid
390            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
391            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
392            * @throws SystemException if a system exception occurred
393            */
394            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_Last(
395                    java.lang.String uuid,
396                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
397                    throws com.liferay.portal.kernel.exception.SystemException {
398                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
399            }
400    
401            /**
402            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where uuid = &#63;.
403            *
404            * @param entryId the primary key of the current bookmarks entry
405            * @param uuid the uuid
406            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
407            * @return the previous, current, and next bookmarks entry
408            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
409            * @throws SystemException if a system exception occurred
410            */
411            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByUuid_PrevAndNext(
412                    long entryId, java.lang.String uuid,
413                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
414                    throws com.liferay.portal.kernel.exception.SystemException,
415                            com.liferay.portlet.bookmarks.NoSuchEntryException {
416                    return getPersistence()
417                                       .findByUuid_PrevAndNext(entryId, uuid, orderByComparator);
418            }
419    
420            /**
421            * Removes all the bookmarks entries where uuid = &#63; from the database.
422            *
423            * @param uuid the uuid
424            * @throws SystemException if a system exception occurred
425            */
426            public static void removeByUuid(java.lang.String uuid)
427                    throws com.liferay.portal.kernel.exception.SystemException {
428                    getPersistence().removeByUuid(uuid);
429            }
430    
431            /**
432            * Returns the number of bookmarks entries where uuid = &#63;.
433            *
434            * @param uuid the uuid
435            * @return the number of matching bookmarks entries
436            * @throws SystemException if a system exception occurred
437            */
438            public static int countByUuid(java.lang.String uuid)
439                    throws com.liferay.portal.kernel.exception.SystemException {
440                    return getPersistence().countByUuid(uuid);
441            }
442    
443            /**
444            * Returns the bookmarks entry where uuid = &#63; and groupId = &#63; or throws a {@link com.liferay.portlet.bookmarks.NoSuchEntryException} if it could not be found.
445            *
446            * @param uuid the uuid
447            * @param groupId the group ID
448            * @return the matching bookmarks entry
449            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
450            * @throws SystemException if a system exception occurred
451            */
452            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUUID_G(
453                    java.lang.String uuid, long groupId)
454                    throws com.liferay.portal.kernel.exception.SystemException,
455                            com.liferay.portlet.bookmarks.NoSuchEntryException {
456                    return getPersistence().findByUUID_G(uuid, groupId);
457            }
458    
459            /**
460            * Returns the bookmarks entry where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
461            *
462            * @param uuid the uuid
463            * @param groupId the group ID
464            * @return the matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
465            * @throws SystemException if a system exception occurred
466            */
467            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUUID_G(
468                    java.lang.String uuid, long groupId)
469                    throws com.liferay.portal.kernel.exception.SystemException {
470                    return getPersistence().fetchByUUID_G(uuid, groupId);
471            }
472    
473            /**
474            * Returns the bookmarks entry where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
475            *
476            * @param uuid the uuid
477            * @param groupId the group ID
478            * @param retrieveFromCache whether to use the finder cache
479            * @return the matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
480            * @throws SystemException if a system exception occurred
481            */
482            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUUID_G(
483                    java.lang.String uuid, long groupId, boolean retrieveFromCache)
484                    throws com.liferay.portal.kernel.exception.SystemException {
485                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
486            }
487    
488            /**
489            * Removes the bookmarks entry where uuid = &#63; and groupId = &#63; from the database.
490            *
491            * @param uuid the uuid
492            * @param groupId the group ID
493            * @return the bookmarks entry that was removed
494            * @throws SystemException if a system exception occurred
495            */
496            public static com.liferay.portlet.bookmarks.model.BookmarksEntry removeByUUID_G(
497                    java.lang.String uuid, long groupId)
498                    throws com.liferay.portal.kernel.exception.SystemException,
499                            com.liferay.portlet.bookmarks.NoSuchEntryException {
500                    return getPersistence().removeByUUID_G(uuid, groupId);
501            }
502    
503            /**
504            * Returns the number of bookmarks entries where uuid = &#63; and groupId = &#63;.
505            *
506            * @param uuid the uuid
507            * @param groupId the group ID
508            * @return the number of matching bookmarks entries
509            * @throws SystemException if a system exception occurred
510            */
511            public static int countByUUID_G(java.lang.String uuid, long groupId)
512                    throws com.liferay.portal.kernel.exception.SystemException {
513                    return getPersistence().countByUUID_G(uuid, groupId);
514            }
515    
516            /**
517            * Returns all the bookmarks entries where uuid = &#63; and companyId = &#63;.
518            *
519            * @param uuid the uuid
520            * @param companyId the company ID
521            * @return the matching bookmarks entries
522            * @throws SystemException if a system exception occurred
523            */
524            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid_C(
525                    java.lang.String uuid, long companyId)
526                    throws com.liferay.portal.kernel.exception.SystemException {
527                    return getPersistence().findByUuid_C(uuid, companyId);
528            }
529    
530            /**
531            * Returns a range of all the bookmarks entries where uuid = &#63; and companyId = &#63;.
532            *
533            * <p>
534            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
535            * </p>
536            *
537            * @param uuid the uuid
538            * @param companyId the company ID
539            * @param start the lower bound of the range of bookmarks entries
540            * @param end the upper bound of the range of bookmarks entries (not inclusive)
541            * @return the range of matching bookmarks entries
542            * @throws SystemException if a system exception occurred
543            */
544            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid_C(
545                    java.lang.String uuid, long companyId, int start, int end)
546                    throws com.liferay.portal.kernel.exception.SystemException {
547                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
548            }
549    
550            /**
551            * Returns an ordered range of all the bookmarks entries where uuid = &#63; and companyId = &#63;.
552            *
553            * <p>
554            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
555            * </p>
556            *
557            * @param uuid the uuid
558            * @param companyId the company ID
559            * @param start the lower bound of the range of bookmarks entries
560            * @param end the upper bound of the range of bookmarks entries (not inclusive)
561            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
562            * @return the ordered range of matching bookmarks entries
563            * @throws SystemException if a system exception occurred
564            */
565            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid_C(
566                    java.lang.String uuid, long companyId, int start, int end,
567                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
568                    throws com.liferay.portal.kernel.exception.SystemException {
569                    return getPersistence()
570                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
571            }
572    
573            /**
574            * Returns the first bookmarks entry in the ordered set where uuid = &#63; and companyId = &#63;.
575            *
576            * @param uuid the uuid
577            * @param companyId the company ID
578            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
579            * @return the first matching bookmarks entry
580            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
581            * @throws SystemException if a system exception occurred
582            */
583            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_C_First(
584                    java.lang.String uuid, long companyId,
585                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
586                    throws com.liferay.portal.kernel.exception.SystemException,
587                            com.liferay.portlet.bookmarks.NoSuchEntryException {
588                    return getPersistence()
589                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
590            }
591    
592            /**
593            * Returns the first bookmarks entry in the ordered set where uuid = &#63; and companyId = &#63;.
594            *
595            * @param uuid the uuid
596            * @param companyId the company ID
597            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
598            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
599            * @throws SystemException if a system exception occurred
600            */
601            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_C_First(
602                    java.lang.String uuid, long companyId,
603                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
604                    throws com.liferay.portal.kernel.exception.SystemException {
605                    return getPersistence()
606                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
607            }
608    
609            /**
610            * Returns the last bookmarks entry in the ordered set where uuid = &#63; and companyId = &#63;.
611            *
612            * @param uuid the uuid
613            * @param companyId the company ID
614            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
615            * @return the last matching bookmarks entry
616            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
617            * @throws SystemException if a system exception occurred
618            */
619            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_C_Last(
620                    java.lang.String uuid, long companyId,
621                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
622                    throws com.liferay.portal.kernel.exception.SystemException,
623                            com.liferay.portlet.bookmarks.NoSuchEntryException {
624                    return getPersistence()
625                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
626            }
627    
628            /**
629            * Returns the last bookmarks entry in the ordered set where uuid = &#63; and companyId = &#63;.
630            *
631            * @param uuid the uuid
632            * @param companyId the company ID
633            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
634            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
635            * @throws SystemException if a system exception occurred
636            */
637            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_C_Last(
638                    java.lang.String uuid, long companyId,
639                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
640                    throws com.liferay.portal.kernel.exception.SystemException {
641                    return getPersistence()
642                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
643            }
644    
645            /**
646            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where uuid = &#63; and companyId = &#63;.
647            *
648            * @param entryId the primary key of the current bookmarks entry
649            * @param uuid the uuid
650            * @param companyId the company ID
651            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
652            * @return the previous, current, and next bookmarks entry
653            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
654            * @throws SystemException if a system exception occurred
655            */
656            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByUuid_C_PrevAndNext(
657                    long entryId, java.lang.String uuid, long companyId,
658                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
659                    throws com.liferay.portal.kernel.exception.SystemException,
660                            com.liferay.portlet.bookmarks.NoSuchEntryException {
661                    return getPersistence()
662                                       .findByUuid_C_PrevAndNext(entryId, uuid, companyId,
663                            orderByComparator);
664            }
665    
666            /**
667            * Removes all the bookmarks entries where uuid = &#63; and companyId = &#63; from the database.
668            *
669            * @param uuid the uuid
670            * @param companyId the company ID
671            * @throws SystemException if a system exception occurred
672            */
673            public static void removeByUuid_C(java.lang.String uuid, long companyId)
674                    throws com.liferay.portal.kernel.exception.SystemException {
675                    getPersistence().removeByUuid_C(uuid, companyId);
676            }
677    
678            /**
679            * Returns the number of bookmarks entries where uuid = &#63; and companyId = &#63;.
680            *
681            * @param uuid the uuid
682            * @param companyId the company ID
683            * @return the number of matching bookmarks entries
684            * @throws SystemException if a system exception occurred
685            */
686            public static int countByUuid_C(java.lang.String uuid, long companyId)
687                    throws com.liferay.portal.kernel.exception.SystemException {
688                    return getPersistence().countByUuid_C(uuid, companyId);
689            }
690    
691            /**
692            * Returns all the bookmarks entries where groupId = &#63; and folderId = &#63;.
693            *
694            * @param groupId the group ID
695            * @param folderId the folder ID
696            * @return the matching bookmarks entries
697            * @throws SystemException if a system exception occurred
698            */
699            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
700                    long groupId, long folderId)
701                    throws com.liferay.portal.kernel.exception.SystemException {
702                    return getPersistence().findByG_F(groupId, folderId);
703            }
704    
705            /**
706            * Returns a range of all the bookmarks entries where groupId = &#63; and folderId = &#63;.
707            *
708            * <p>
709            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
710            * </p>
711            *
712            * @param groupId the group ID
713            * @param folderId the folder ID
714            * @param start the lower bound of the range of bookmarks entries
715            * @param end the upper bound of the range of bookmarks entries (not inclusive)
716            * @return the range of matching bookmarks entries
717            * @throws SystemException if a system exception occurred
718            */
719            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
720                    long groupId, long folderId, int start, int end)
721                    throws com.liferay.portal.kernel.exception.SystemException {
722                    return getPersistence().findByG_F(groupId, folderId, start, end);
723            }
724    
725            /**
726            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and folderId = &#63;.
727            *
728            * <p>
729            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
730            * </p>
731            *
732            * @param groupId the group ID
733            * @param folderId the folder ID
734            * @param start the lower bound of the range of bookmarks entries
735            * @param end the upper bound of the range of bookmarks entries (not inclusive)
736            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
737            * @return the ordered range of matching bookmarks entries
738            * @throws SystemException if a system exception occurred
739            */
740            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
741                    long groupId, long folderId, int start, int end,
742                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
743                    throws com.liferay.portal.kernel.exception.SystemException {
744                    return getPersistence()
745                                       .findByG_F(groupId, folderId, start, end, orderByComparator);
746            }
747    
748            /**
749            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63;.
750            *
751            * @param groupId the group ID
752            * @param folderId the folder ID
753            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
754            * @return the first matching bookmarks entry
755            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
756            * @throws SystemException if a system exception occurred
757            */
758            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_First(
759                    long groupId, long folderId,
760                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
761                    throws com.liferay.portal.kernel.exception.SystemException,
762                            com.liferay.portlet.bookmarks.NoSuchEntryException {
763                    return getPersistence()
764                                       .findByG_F_First(groupId, folderId, orderByComparator);
765            }
766    
767            /**
768            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63;.
769            *
770            * @param groupId the group ID
771            * @param folderId the folder ID
772            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
773            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
774            * @throws SystemException if a system exception occurred
775            */
776            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_First(
777                    long groupId, long folderId,
778                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
779                    throws com.liferay.portal.kernel.exception.SystemException {
780                    return getPersistence()
781                                       .fetchByG_F_First(groupId, folderId, orderByComparator);
782            }
783    
784            /**
785            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63;.
786            *
787            * @param groupId the group ID
788            * @param folderId the folder ID
789            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
790            * @return the last matching bookmarks entry
791            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
792            * @throws SystemException if a system exception occurred
793            */
794            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_Last(
795                    long groupId, long folderId,
796                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
797                    throws com.liferay.portal.kernel.exception.SystemException,
798                            com.liferay.portlet.bookmarks.NoSuchEntryException {
799                    return getPersistence()
800                                       .findByG_F_Last(groupId, folderId, orderByComparator);
801            }
802    
803            /**
804            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63;.
805            *
806            * @param groupId the group ID
807            * @param folderId the folder ID
808            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
809            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
810            * @throws SystemException if a system exception occurred
811            */
812            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_Last(
813                    long groupId, long folderId,
814                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
815                    throws com.liferay.portal.kernel.exception.SystemException {
816                    return getPersistence()
817                                       .fetchByG_F_Last(groupId, folderId, orderByComparator);
818            }
819    
820            /**
821            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63;.
822            *
823            * @param entryId the primary key of the current bookmarks entry
824            * @param groupId the group ID
825            * @param folderId the folder ID
826            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
827            * @return the previous, current, and next bookmarks entry
828            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
829            * @throws SystemException if a system exception occurred
830            */
831            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_PrevAndNext(
832                    long entryId, long groupId, long folderId,
833                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
834                    throws com.liferay.portal.kernel.exception.SystemException,
835                            com.liferay.portlet.bookmarks.NoSuchEntryException {
836                    return getPersistence()
837                                       .findByG_F_PrevAndNext(entryId, groupId, folderId,
838                            orderByComparator);
839            }
840    
841            /**
842            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63;.
843            *
844            * @param groupId the group ID
845            * @param folderId the folder ID
846            * @return the matching bookmarks entries that the user has permission to view
847            * @throws SystemException if a system exception occurred
848            */
849            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
850                    long groupId, long folderId)
851                    throws com.liferay.portal.kernel.exception.SystemException {
852                    return getPersistence().filterFindByG_F(groupId, folderId);
853            }
854    
855            /**
856            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63;.
857            *
858            * <p>
859            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
860            * </p>
861            *
862            * @param groupId the group ID
863            * @param folderId the folder ID
864            * @param start the lower bound of the range of bookmarks entries
865            * @param end the upper bound of the range of bookmarks entries (not inclusive)
866            * @return the range of matching bookmarks entries that the user has permission to view
867            * @throws SystemException if a system exception occurred
868            */
869            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
870                    long groupId, long folderId, int start, int end)
871                    throws com.liferay.portal.kernel.exception.SystemException {
872                    return getPersistence().filterFindByG_F(groupId, folderId, start, end);
873            }
874    
875            /**
876            * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = &#63; and folderId = &#63;.
877            *
878            * <p>
879            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
880            * </p>
881            *
882            * @param groupId the group ID
883            * @param folderId the folder ID
884            * @param start the lower bound of the range of bookmarks entries
885            * @param end the upper bound of the range of bookmarks entries (not inclusive)
886            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
887            * @return the ordered range of matching bookmarks entries that the user has permission to view
888            * @throws SystemException if a system exception occurred
889            */
890            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
891                    long groupId, long folderId, int start, int end,
892                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
893                    throws com.liferay.portal.kernel.exception.SystemException {
894                    return getPersistence()
895                                       .filterFindByG_F(groupId, folderId, start, end,
896                            orderByComparator);
897            }
898    
899            /**
900            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63;.
901            *
902            * @param entryId the primary key of the current bookmarks entry
903            * @param groupId the group ID
904            * @param folderId the folder ID
905            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
906            * @return the previous, current, and next bookmarks entry
907            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
908            * @throws SystemException if a system exception occurred
909            */
910            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_PrevAndNext(
911                    long entryId, long groupId, long folderId,
912                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
913                    throws com.liferay.portal.kernel.exception.SystemException,
914                            com.liferay.portlet.bookmarks.NoSuchEntryException {
915                    return getPersistence()
916                                       .filterFindByG_F_PrevAndNext(entryId, groupId, folderId,
917                            orderByComparator);
918            }
919    
920            /**
921            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63;.
922            *
923            * @param groupId the group ID
924            * @param folderIds the folder IDs
925            * @return the matching bookmarks entries that the user has permission to view
926            * @throws SystemException if a system exception occurred
927            */
928            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
929                    long groupId, long[] folderIds)
930                    throws com.liferay.portal.kernel.exception.SystemException {
931                    return getPersistence().filterFindByG_F(groupId, folderIds);
932            }
933    
934            /**
935            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63;.
936            *
937            * <p>
938            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
939            * </p>
940            *
941            * @param groupId the group ID
942            * @param folderIds the folder IDs
943            * @param start the lower bound of the range of bookmarks entries
944            * @param end the upper bound of the range of bookmarks entries (not inclusive)
945            * @return the range of matching bookmarks entries that the user has permission to view
946            * @throws SystemException if a system exception occurred
947            */
948            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
949                    long groupId, long[] folderIds, int start, int end)
950                    throws com.liferay.portal.kernel.exception.SystemException {
951                    return getPersistence().filterFindByG_F(groupId, folderIds, start, end);
952            }
953    
954            /**
955            * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63;.
956            *
957            * <p>
958            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
959            * </p>
960            *
961            * @param groupId the group ID
962            * @param folderIds the folder IDs
963            * @param start the lower bound of the range of bookmarks entries
964            * @param end the upper bound of the range of bookmarks entries (not inclusive)
965            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
966            * @return the ordered range of matching bookmarks entries that the user has permission to view
967            * @throws SystemException if a system exception occurred
968            */
969            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F(
970                    long groupId, long[] folderIds, int start, int end,
971                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
972                    throws com.liferay.portal.kernel.exception.SystemException {
973                    return getPersistence()
974                                       .filterFindByG_F(groupId, folderIds, start, end,
975                            orderByComparator);
976            }
977    
978            /**
979            * Returns all the bookmarks entries where groupId = &#63; and folderId = any &#63;.
980            *
981            * <p>
982            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
983            * </p>
984            *
985            * @param groupId the group ID
986            * @param folderIds the folder IDs
987            * @return the matching bookmarks entries
988            * @throws SystemException if a system exception occurred
989            */
990            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
991                    long groupId, long[] folderIds)
992                    throws com.liferay.portal.kernel.exception.SystemException {
993                    return getPersistence().findByG_F(groupId, folderIds);
994            }
995    
996            /**
997            * Returns a range of all the bookmarks entries where groupId = &#63; and folderId = any &#63;.
998            *
999            * <p>
1000            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1001            * </p>
1002            *
1003            * @param groupId the group ID
1004            * @param folderIds the folder IDs
1005            * @param start the lower bound of the range of bookmarks entries
1006            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1007            * @return the range of matching bookmarks entries
1008            * @throws SystemException if a system exception occurred
1009            */
1010            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
1011                    long groupId, long[] folderIds, int start, int end)
1012                    throws com.liferay.portal.kernel.exception.SystemException {
1013                    return getPersistence().findByG_F(groupId, folderIds, start, end);
1014            }
1015    
1016            /**
1017            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and folderId = any &#63;.
1018            *
1019            * <p>
1020            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1021            * </p>
1022            *
1023            * @param groupId the group ID
1024            * @param folderIds the folder IDs
1025            * @param start the lower bound of the range of bookmarks entries
1026            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1027            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1028            * @return the ordered range of matching bookmarks entries
1029            * @throws SystemException if a system exception occurred
1030            */
1031            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F(
1032                    long groupId, long[] folderIds, int start, int end,
1033                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1034                    throws com.liferay.portal.kernel.exception.SystemException {
1035                    return getPersistence()
1036                                       .findByG_F(groupId, folderIds, start, end, orderByComparator);
1037            }
1038    
1039            /**
1040            * Removes all the bookmarks entries where groupId = &#63; and folderId = &#63; from the database.
1041            *
1042            * @param groupId the group ID
1043            * @param folderId the folder ID
1044            * @throws SystemException if a system exception occurred
1045            */
1046            public static void removeByG_F(long groupId, long folderId)
1047                    throws com.liferay.portal.kernel.exception.SystemException {
1048                    getPersistence().removeByG_F(groupId, folderId);
1049            }
1050    
1051            /**
1052            * Returns the number of bookmarks entries where groupId = &#63; and folderId = &#63;.
1053            *
1054            * @param groupId the group ID
1055            * @param folderId the folder ID
1056            * @return the number of matching bookmarks entries
1057            * @throws SystemException if a system exception occurred
1058            */
1059            public static int countByG_F(long groupId, long folderId)
1060                    throws com.liferay.portal.kernel.exception.SystemException {
1061                    return getPersistence().countByG_F(groupId, folderId);
1062            }
1063    
1064            /**
1065            * Returns the number of bookmarks entries where groupId = &#63; and folderId = any &#63;.
1066            *
1067            * @param groupId the group ID
1068            * @param folderIds the folder IDs
1069            * @return the number of matching bookmarks entries
1070            * @throws SystemException if a system exception occurred
1071            */
1072            public static int countByG_F(long groupId, long[] folderIds)
1073                    throws com.liferay.portal.kernel.exception.SystemException {
1074                    return getPersistence().countByG_F(groupId, folderIds);
1075            }
1076    
1077            /**
1078            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63;.
1079            *
1080            * @param groupId the group ID
1081            * @param folderId the folder ID
1082            * @return the number of matching bookmarks entries that the user has permission to view
1083            * @throws SystemException if a system exception occurred
1084            */
1085            public static int filterCountByG_F(long groupId, long folderId)
1086                    throws com.liferay.portal.kernel.exception.SystemException {
1087                    return getPersistence().filterCountByG_F(groupId, folderId);
1088            }
1089    
1090            /**
1091            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63;.
1092            *
1093            * @param groupId the group ID
1094            * @param folderIds the folder IDs
1095            * @return the number of matching bookmarks entries that the user has permission to view
1096            * @throws SystemException if a system exception occurred
1097            */
1098            public static int filterCountByG_F(long groupId, long[] folderIds)
1099                    throws com.liferay.portal.kernel.exception.SystemException {
1100                    return getPersistence().filterCountByG_F(groupId, folderIds);
1101            }
1102    
1103            /**
1104            * Returns all the bookmarks entries where groupId = &#63; and status = &#63;.
1105            *
1106            * @param groupId the group ID
1107            * @param status the status
1108            * @return the matching bookmarks entries
1109            * @throws SystemException if a system exception occurred
1110            */
1111            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_S(
1112                    long groupId, int status)
1113                    throws com.liferay.portal.kernel.exception.SystemException {
1114                    return getPersistence().findByG_S(groupId, status);
1115            }
1116    
1117            /**
1118            * Returns a range of all the bookmarks entries where groupId = &#63; and status = &#63;.
1119            *
1120            * <p>
1121            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1122            * </p>
1123            *
1124            * @param groupId the group ID
1125            * @param status the status
1126            * @param start the lower bound of the range of bookmarks entries
1127            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1128            * @return the range of matching bookmarks entries
1129            * @throws SystemException if a system exception occurred
1130            */
1131            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_S(
1132                    long groupId, int status, int start, int end)
1133                    throws com.liferay.portal.kernel.exception.SystemException {
1134                    return getPersistence().findByG_S(groupId, status, start, end);
1135            }
1136    
1137            /**
1138            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and status = &#63;.
1139            *
1140            * <p>
1141            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1142            * </p>
1143            *
1144            * @param groupId the group ID
1145            * @param status the status
1146            * @param start the lower bound of the range of bookmarks entries
1147            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1148            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1149            * @return the ordered range of matching bookmarks entries
1150            * @throws SystemException if a system exception occurred
1151            */
1152            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_S(
1153                    long groupId, int status, int start, int end,
1154                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1155                    throws com.liferay.portal.kernel.exception.SystemException {
1156                    return getPersistence()
1157                                       .findByG_S(groupId, status, start, end, orderByComparator);
1158            }
1159    
1160            /**
1161            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and status = &#63;.
1162            *
1163            * @param groupId the group ID
1164            * @param status the status
1165            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1166            * @return the first matching bookmarks entry
1167            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1168            * @throws SystemException if a system exception occurred
1169            */
1170            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_S_First(
1171                    long groupId, int status,
1172                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1173                    throws com.liferay.portal.kernel.exception.SystemException,
1174                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1175                    return getPersistence()
1176                                       .findByG_S_First(groupId, status, orderByComparator);
1177            }
1178    
1179            /**
1180            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and status = &#63;.
1181            *
1182            * @param groupId the group ID
1183            * @param status the status
1184            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1185            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1186            * @throws SystemException if a system exception occurred
1187            */
1188            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_S_First(
1189                    long groupId, int status,
1190                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1191                    throws com.liferay.portal.kernel.exception.SystemException {
1192                    return getPersistence()
1193                                       .fetchByG_S_First(groupId, status, orderByComparator);
1194            }
1195    
1196            /**
1197            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and status = &#63;.
1198            *
1199            * @param groupId the group ID
1200            * @param status the status
1201            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1202            * @return the last matching bookmarks entry
1203            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1204            * @throws SystemException if a system exception occurred
1205            */
1206            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_S_Last(
1207                    long groupId, int status,
1208                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1209                    throws com.liferay.portal.kernel.exception.SystemException,
1210                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1211                    return getPersistence()
1212                                       .findByG_S_Last(groupId, status, orderByComparator);
1213            }
1214    
1215            /**
1216            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and status = &#63;.
1217            *
1218            * @param groupId the group ID
1219            * @param status the status
1220            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1221            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1222            * @throws SystemException if a system exception occurred
1223            */
1224            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_S_Last(
1225                    long groupId, int status,
1226                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1227                    throws com.liferay.portal.kernel.exception.SystemException {
1228                    return getPersistence()
1229                                       .fetchByG_S_Last(groupId, status, orderByComparator);
1230            }
1231    
1232            /**
1233            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63; and status = &#63;.
1234            *
1235            * @param entryId the primary key of the current bookmarks entry
1236            * @param groupId the group ID
1237            * @param status the status
1238            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1239            * @return the previous, current, and next bookmarks entry
1240            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1241            * @throws SystemException if a system exception occurred
1242            */
1243            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_S_PrevAndNext(
1244                    long entryId, long groupId, int status,
1245                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1246                    throws com.liferay.portal.kernel.exception.SystemException,
1247                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1248                    return getPersistence()
1249                                       .findByG_S_PrevAndNext(entryId, groupId, status,
1250                            orderByComparator);
1251            }
1252    
1253            /**
1254            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and status = &#63;.
1255            *
1256            * @param groupId the group ID
1257            * @param status the status
1258            * @return the matching bookmarks entries that the user has permission to view
1259            * @throws SystemException if a system exception occurred
1260            */
1261            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_S(
1262                    long groupId, int status)
1263                    throws com.liferay.portal.kernel.exception.SystemException {
1264                    return getPersistence().filterFindByG_S(groupId, status);
1265            }
1266    
1267            /**
1268            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and status = &#63;.
1269            *
1270            * <p>
1271            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1272            * </p>
1273            *
1274            * @param groupId the group ID
1275            * @param status the status
1276            * @param start the lower bound of the range of bookmarks entries
1277            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1278            * @return the range of matching bookmarks entries that the user has permission to view
1279            * @throws SystemException if a system exception occurred
1280            */
1281            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_S(
1282                    long groupId, int status, int start, int end)
1283                    throws com.liferay.portal.kernel.exception.SystemException {
1284                    return getPersistence().filterFindByG_S(groupId, status, start, end);
1285            }
1286    
1287            /**
1288            * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = &#63; and status = &#63;.
1289            *
1290            * <p>
1291            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1292            * </p>
1293            *
1294            * @param groupId the group ID
1295            * @param status the status
1296            * @param start the lower bound of the range of bookmarks entries
1297            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1298            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1299            * @return the ordered range of matching bookmarks entries that the user has permission to view
1300            * @throws SystemException if a system exception occurred
1301            */
1302            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_S(
1303                    long groupId, int status, int start, int end,
1304                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1305                    throws com.liferay.portal.kernel.exception.SystemException {
1306                    return getPersistence()
1307                                       .filterFindByG_S(groupId, status, start, end,
1308                            orderByComparator);
1309            }
1310    
1311            /**
1312            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set of bookmarks entries that the user has permission to view where groupId = &#63; and status = &#63;.
1313            *
1314            * @param entryId the primary key of the current bookmarks entry
1315            * @param groupId the group ID
1316            * @param status the status
1317            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1318            * @return the previous, current, and next bookmarks entry
1319            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1320            * @throws SystemException if a system exception occurred
1321            */
1322            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_S_PrevAndNext(
1323                    long entryId, long groupId, int status,
1324                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1325                    throws com.liferay.portal.kernel.exception.SystemException,
1326                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1327                    return getPersistence()
1328                                       .filterFindByG_S_PrevAndNext(entryId, groupId, status,
1329                            orderByComparator);
1330            }
1331    
1332            /**
1333            * Removes all the bookmarks entries where groupId = &#63; and status = &#63; from the database.
1334            *
1335            * @param groupId the group ID
1336            * @param status the status
1337            * @throws SystemException if a system exception occurred
1338            */
1339            public static void removeByG_S(long groupId, int status)
1340                    throws com.liferay.portal.kernel.exception.SystemException {
1341                    getPersistence().removeByG_S(groupId, status);
1342            }
1343    
1344            /**
1345            * Returns the number of bookmarks entries where groupId = &#63; and status = &#63;.
1346            *
1347            * @param groupId the group ID
1348            * @param status the status
1349            * @return the number of matching bookmarks entries
1350            * @throws SystemException if a system exception occurred
1351            */
1352            public static int countByG_S(long groupId, int status)
1353                    throws com.liferay.portal.kernel.exception.SystemException {
1354                    return getPersistence().countByG_S(groupId, status);
1355            }
1356    
1357            /**
1358            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and status = &#63;.
1359            *
1360            * @param groupId the group ID
1361            * @param status the status
1362            * @return the number of matching bookmarks entries that the user has permission to view
1363            * @throws SystemException if a system exception occurred
1364            */
1365            public static int filterCountByG_S(long groupId, int status)
1366                    throws com.liferay.portal.kernel.exception.SystemException {
1367                    return getPersistence().filterCountByG_S(groupId, status);
1368            }
1369    
1370            /**
1371            * Returns all the bookmarks entries where groupId = &#63; and userId = &#63; and status = &#63;.
1372            *
1373            * @param groupId the group ID
1374            * @param userId the user ID
1375            * @param status the status
1376            * @return the matching bookmarks entries
1377            * @throws SystemException if a system exception occurred
1378            */
1379            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S(
1380                    long groupId, long userId, int status)
1381                    throws com.liferay.portal.kernel.exception.SystemException {
1382                    return getPersistence().findByG_U_S(groupId, userId, status);
1383            }
1384    
1385            /**
1386            * Returns a range of all the bookmarks entries where groupId = &#63; and userId = &#63; and status = &#63;.
1387            *
1388            * <p>
1389            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1390            * </p>
1391            *
1392            * @param groupId the group ID
1393            * @param userId the user ID
1394            * @param status the status
1395            * @param start the lower bound of the range of bookmarks entries
1396            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1397            * @return the range of matching bookmarks entries
1398            * @throws SystemException if a system exception occurred
1399            */
1400            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S(
1401                    long groupId, long userId, int status, int start, int end)
1402                    throws com.liferay.portal.kernel.exception.SystemException {
1403                    return getPersistence().findByG_U_S(groupId, userId, status, start, end);
1404            }
1405    
1406            /**
1407            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and userId = &#63; and status = &#63;.
1408            *
1409            * <p>
1410            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1411            * </p>
1412            *
1413            * @param groupId the group ID
1414            * @param userId the user ID
1415            * @param status the status
1416            * @param start the lower bound of the range of bookmarks entries
1417            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1418            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1419            * @return the ordered range of matching bookmarks entries
1420            * @throws SystemException if a system exception occurred
1421            */
1422            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S(
1423                    long groupId, long userId, int status, int start, int end,
1424                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1425                    throws com.liferay.portal.kernel.exception.SystemException {
1426                    return getPersistence()
1427                                       .findByG_U_S(groupId, userId, status, start, end,
1428                            orderByComparator);
1429            }
1430    
1431            /**
1432            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
1433            *
1434            * @param groupId the group ID
1435            * @param userId the user ID
1436            * @param status the status
1437            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1438            * @return the first matching bookmarks entry
1439            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1440            * @throws SystemException if a system exception occurred
1441            */
1442            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_S_First(
1443                    long groupId, long userId, int status,
1444                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1445                    throws com.liferay.portal.kernel.exception.SystemException,
1446                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1447                    return getPersistence()
1448                                       .findByG_U_S_First(groupId, userId, status, orderByComparator);
1449            }
1450    
1451            /**
1452            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
1453            *
1454            * @param groupId the group ID
1455            * @param userId the user ID
1456            * @param status the status
1457            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1458            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1459            * @throws SystemException if a system exception occurred
1460            */
1461            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_S_First(
1462                    long groupId, long userId, int status,
1463                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1464                    throws com.liferay.portal.kernel.exception.SystemException {
1465                    return getPersistence()
1466                                       .fetchByG_U_S_First(groupId, userId, status,
1467                            orderByComparator);
1468            }
1469    
1470            /**
1471            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
1472            *
1473            * @param groupId the group ID
1474            * @param userId the user ID
1475            * @param status the status
1476            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1477            * @return the last matching bookmarks entry
1478            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1479            * @throws SystemException if a system exception occurred
1480            */
1481            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_S_Last(
1482                    long groupId, long userId, int status,
1483                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1484                    throws com.liferay.portal.kernel.exception.SystemException,
1485                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1486                    return getPersistence()
1487                                       .findByG_U_S_Last(groupId, userId, status, orderByComparator);
1488            }
1489    
1490            /**
1491            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
1492            *
1493            * @param groupId the group ID
1494            * @param userId the user ID
1495            * @param status the status
1496            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1497            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1498            * @throws SystemException if a system exception occurred
1499            */
1500            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_S_Last(
1501                    long groupId, long userId, int status,
1502                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1503                    throws com.liferay.portal.kernel.exception.SystemException {
1504                    return getPersistence()
1505                                       .fetchByG_U_S_Last(groupId, userId, status, orderByComparator);
1506            }
1507    
1508            /**
1509            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
1510            *
1511            * @param entryId the primary key of the current bookmarks entry
1512            * @param groupId the group ID
1513            * @param userId the user ID
1514            * @param status the status
1515            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1516            * @return the previous, current, and next bookmarks entry
1517            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1518            * @throws SystemException if a system exception occurred
1519            */
1520            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_U_S_PrevAndNext(
1521                    long entryId, long groupId, long userId, int status,
1522                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1523                    throws com.liferay.portal.kernel.exception.SystemException,
1524                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1525                    return getPersistence()
1526                                       .findByG_U_S_PrevAndNext(entryId, groupId, userId, status,
1527                            orderByComparator);
1528            }
1529    
1530            /**
1531            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and status = &#63;.
1532            *
1533            * @param groupId the group ID
1534            * @param userId the user ID
1535            * @param status the status
1536            * @return the matching bookmarks entries that the user has permission to view
1537            * @throws SystemException if a system exception occurred
1538            */
1539            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S(
1540                    long groupId, long userId, int status)
1541                    throws com.liferay.portal.kernel.exception.SystemException {
1542                    return getPersistence().filterFindByG_U_S(groupId, userId, status);
1543            }
1544    
1545            /**
1546            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and status = &#63;.
1547            *
1548            * <p>
1549            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1550            * </p>
1551            *
1552            * @param groupId the group ID
1553            * @param userId the user ID
1554            * @param status the status
1555            * @param start the lower bound of the range of bookmarks entries
1556            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1557            * @return the range of matching bookmarks entries that the user has permission to view
1558            * @throws SystemException if a system exception occurred
1559            */
1560            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S(
1561                    long groupId, long userId, int status, int start, int end)
1562                    throws com.liferay.portal.kernel.exception.SystemException {
1563                    return getPersistence()
1564                                       .filterFindByG_U_S(groupId, userId, status, start, end);
1565            }
1566    
1567            /**
1568            * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = &#63; and userId = &#63; and status = &#63;.
1569            *
1570            * <p>
1571            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1572            * </p>
1573            *
1574            * @param groupId the group ID
1575            * @param userId the user ID
1576            * @param status the status
1577            * @param start the lower bound of the range of bookmarks entries
1578            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1579            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1580            * @return the ordered range of matching bookmarks entries that the user has permission to view
1581            * @throws SystemException if a system exception occurred
1582            */
1583            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S(
1584                    long groupId, long userId, int status, int start, int end,
1585                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1586                    throws com.liferay.portal.kernel.exception.SystemException {
1587                    return getPersistence()
1588                                       .filterFindByG_U_S(groupId, userId, status, start, end,
1589                            orderByComparator);
1590            }
1591    
1592            /**
1593            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set of bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and status = &#63;.
1594            *
1595            * @param entryId the primary key of the current bookmarks entry
1596            * @param groupId the group ID
1597            * @param userId the user ID
1598            * @param status the status
1599            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1600            * @return the previous, current, and next bookmarks entry
1601            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1602            * @throws SystemException if a system exception occurred
1603            */
1604            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_U_S_PrevAndNext(
1605                    long entryId, long groupId, long userId, int status,
1606                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1607                    throws com.liferay.portal.kernel.exception.SystemException,
1608                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1609                    return getPersistence()
1610                                       .filterFindByG_U_S_PrevAndNext(entryId, groupId, userId,
1611                            status, orderByComparator);
1612            }
1613    
1614            /**
1615            * Removes all the bookmarks entries where groupId = &#63; and userId = &#63; and status = &#63; from the database.
1616            *
1617            * @param groupId the group ID
1618            * @param userId the user ID
1619            * @param status the status
1620            * @throws SystemException if a system exception occurred
1621            */
1622            public static void removeByG_U_S(long groupId, long userId, int status)
1623                    throws com.liferay.portal.kernel.exception.SystemException {
1624                    getPersistence().removeByG_U_S(groupId, userId, status);
1625            }
1626    
1627            /**
1628            * Returns the number of bookmarks entries where groupId = &#63; and userId = &#63; and status = &#63;.
1629            *
1630            * @param groupId the group ID
1631            * @param userId the user ID
1632            * @param status the status
1633            * @return the number of matching bookmarks entries
1634            * @throws SystemException if a system exception occurred
1635            */
1636            public static int countByG_U_S(long groupId, long userId, int status)
1637                    throws com.liferay.portal.kernel.exception.SystemException {
1638                    return getPersistence().countByG_U_S(groupId, userId, status);
1639            }
1640    
1641            /**
1642            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and status = &#63;.
1643            *
1644            * @param groupId the group ID
1645            * @param userId the user ID
1646            * @param status the status
1647            * @return the number of matching bookmarks entries that the user has permission to view
1648            * @throws SystemException if a system exception occurred
1649            */
1650            public static int filterCountByG_U_S(long groupId, long userId, int status)
1651                    throws com.liferay.portal.kernel.exception.SystemException {
1652                    return getPersistence().filterCountByG_U_S(groupId, userId, status);
1653            }
1654    
1655            /**
1656            * Returns all the bookmarks entries where groupId = &#63; and folderId = &#63; and status = &#63;.
1657            *
1658            * @param groupId the group ID
1659            * @param folderId the folder ID
1660            * @param status the status
1661            * @return the matching bookmarks entries
1662            * @throws SystemException if a system exception occurred
1663            */
1664            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S(
1665                    long groupId, long folderId, int status)
1666                    throws com.liferay.portal.kernel.exception.SystemException {
1667                    return getPersistence().findByG_F_S(groupId, folderId, status);
1668            }
1669    
1670            /**
1671            * Returns a range of all the bookmarks entries where groupId = &#63; and folderId = &#63; and status = &#63;.
1672            *
1673            * <p>
1674            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1675            * </p>
1676            *
1677            * @param groupId the group ID
1678            * @param folderId the folder ID
1679            * @param status the status
1680            * @param start the lower bound of the range of bookmarks entries
1681            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1682            * @return the range of matching bookmarks entries
1683            * @throws SystemException if a system exception occurred
1684            */
1685            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S(
1686                    long groupId, long folderId, int status, int start, int end)
1687                    throws com.liferay.portal.kernel.exception.SystemException {
1688                    return getPersistence()
1689                                       .findByG_F_S(groupId, folderId, status, start, end);
1690            }
1691    
1692            /**
1693            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and folderId = &#63; and status = &#63;.
1694            *
1695            * <p>
1696            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1697            * </p>
1698            *
1699            * @param groupId the group ID
1700            * @param folderId the folder ID
1701            * @param status the status
1702            * @param start the lower bound of the range of bookmarks entries
1703            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1704            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1705            * @return the ordered range of matching bookmarks entries
1706            * @throws SystemException if a system exception occurred
1707            */
1708            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S(
1709                    long groupId, long folderId, int status, int start, int end,
1710                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1711                    throws com.liferay.portal.kernel.exception.SystemException {
1712                    return getPersistence()
1713                                       .findByG_F_S(groupId, folderId, status, start, end,
1714                            orderByComparator);
1715            }
1716    
1717            /**
1718            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
1719            *
1720            * @param groupId the group ID
1721            * @param folderId the folder ID
1722            * @param status the status
1723            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1724            * @return the first matching bookmarks entry
1725            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1726            * @throws SystemException if a system exception occurred
1727            */
1728            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_S_First(
1729                    long groupId, long folderId, int status,
1730                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1731                    throws com.liferay.portal.kernel.exception.SystemException,
1732                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1733                    return getPersistence()
1734                                       .findByG_F_S_First(groupId, folderId, status,
1735                            orderByComparator);
1736            }
1737    
1738            /**
1739            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
1740            *
1741            * @param groupId the group ID
1742            * @param folderId the folder ID
1743            * @param status the status
1744            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1745            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1746            * @throws SystemException if a system exception occurred
1747            */
1748            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_S_First(
1749                    long groupId, long folderId, int status,
1750                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1751                    throws com.liferay.portal.kernel.exception.SystemException {
1752                    return getPersistence()
1753                                       .fetchByG_F_S_First(groupId, folderId, status,
1754                            orderByComparator);
1755            }
1756    
1757            /**
1758            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
1759            *
1760            * @param groupId the group ID
1761            * @param folderId the folder ID
1762            * @param status the status
1763            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1764            * @return the last matching bookmarks entry
1765            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
1766            * @throws SystemException if a system exception occurred
1767            */
1768            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_S_Last(
1769                    long groupId, long folderId, int status,
1770                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1771                    throws com.liferay.portal.kernel.exception.SystemException,
1772                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1773                    return getPersistence()
1774                                       .findByG_F_S_Last(groupId, folderId, status,
1775                            orderByComparator);
1776            }
1777    
1778            /**
1779            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
1780            *
1781            * @param groupId the group ID
1782            * @param folderId the folder ID
1783            * @param status the status
1784            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1785            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
1786            * @throws SystemException if a system exception occurred
1787            */
1788            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_S_Last(
1789                    long groupId, long folderId, int status,
1790                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1791                    throws com.liferay.portal.kernel.exception.SystemException {
1792                    return getPersistence()
1793                                       .fetchByG_F_S_Last(groupId, folderId, status,
1794                            orderByComparator);
1795            }
1796    
1797            /**
1798            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
1799            *
1800            * @param entryId the primary key of the current bookmarks entry
1801            * @param groupId the group ID
1802            * @param folderId the folder ID
1803            * @param status the status
1804            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1805            * @return the previous, current, and next bookmarks entry
1806            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1807            * @throws SystemException if a system exception occurred
1808            */
1809            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_S_PrevAndNext(
1810                    long entryId, long groupId, long folderId, int status,
1811                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1812                    throws com.liferay.portal.kernel.exception.SystemException,
1813                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1814                    return getPersistence()
1815                                       .findByG_F_S_PrevAndNext(entryId, groupId, folderId, status,
1816                            orderByComparator);
1817            }
1818    
1819            /**
1820            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
1821            *
1822            * @param groupId the group ID
1823            * @param folderId the folder ID
1824            * @param status the status
1825            * @return the matching bookmarks entries that the user has permission to view
1826            * @throws SystemException if a system exception occurred
1827            */
1828            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S(
1829                    long groupId, long folderId, int status)
1830                    throws com.liferay.portal.kernel.exception.SystemException {
1831                    return getPersistence().filterFindByG_F_S(groupId, folderId, status);
1832            }
1833    
1834            /**
1835            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
1836            *
1837            * <p>
1838            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1839            * </p>
1840            *
1841            * @param groupId the group ID
1842            * @param folderId the folder ID
1843            * @param status the status
1844            * @param start the lower bound of the range of bookmarks entries
1845            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1846            * @return the range of matching bookmarks entries that the user has permission to view
1847            * @throws SystemException if a system exception occurred
1848            */
1849            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S(
1850                    long groupId, long folderId, int status, int start, int end)
1851                    throws com.liferay.portal.kernel.exception.SystemException {
1852                    return getPersistence()
1853                                       .filterFindByG_F_S(groupId, folderId, status, start, end);
1854            }
1855    
1856            /**
1857            * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = &#63; and folderId = &#63; and status = &#63;.
1858            *
1859            * <p>
1860            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1861            * </p>
1862            *
1863            * @param groupId the group ID
1864            * @param folderId the folder ID
1865            * @param status the status
1866            * @param start the lower bound of the range of bookmarks entries
1867            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1868            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1869            * @return the ordered range of matching bookmarks entries that the user has permission to view
1870            * @throws SystemException if a system exception occurred
1871            */
1872            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S(
1873                    long groupId, long folderId, int status, int start, int end,
1874                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1875                    throws com.liferay.portal.kernel.exception.SystemException {
1876                    return getPersistence()
1877                                       .filterFindByG_F_S(groupId, folderId, status, start, end,
1878                            orderByComparator);
1879            }
1880    
1881            /**
1882            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
1883            *
1884            * @param entryId the primary key of the current bookmarks entry
1885            * @param groupId the group ID
1886            * @param folderId the folder ID
1887            * @param status the status
1888            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1889            * @return the previous, current, and next bookmarks entry
1890            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
1891            * @throws SystemException if a system exception occurred
1892            */
1893            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_S_PrevAndNext(
1894                    long entryId, long groupId, long folderId, int status,
1895                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1896                    throws com.liferay.portal.kernel.exception.SystemException,
1897                            com.liferay.portlet.bookmarks.NoSuchEntryException {
1898                    return getPersistence()
1899                                       .filterFindByG_F_S_PrevAndNext(entryId, groupId, folderId,
1900                            status, orderByComparator);
1901            }
1902    
1903            /**
1904            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63; and status = &#63;.
1905            *
1906            * @param groupId the group ID
1907            * @param folderIds the folder IDs
1908            * @param status the status
1909            * @return the matching bookmarks entries that the user has permission to view
1910            * @throws SystemException if a system exception occurred
1911            */
1912            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S(
1913                    long groupId, long[] folderIds, int status)
1914                    throws com.liferay.portal.kernel.exception.SystemException {
1915                    return getPersistence().filterFindByG_F_S(groupId, folderIds, status);
1916            }
1917    
1918            /**
1919            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63; and status = &#63;.
1920            *
1921            * <p>
1922            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1923            * </p>
1924            *
1925            * @param groupId the group ID
1926            * @param folderIds the folder IDs
1927            * @param status the status
1928            * @param start the lower bound of the range of bookmarks entries
1929            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1930            * @return the range of matching bookmarks entries that the user has permission to view
1931            * @throws SystemException if a system exception occurred
1932            */
1933            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S(
1934                    long groupId, long[] folderIds, int status, int start, int end)
1935                    throws com.liferay.portal.kernel.exception.SystemException {
1936                    return getPersistence()
1937                                       .filterFindByG_F_S(groupId, folderIds, status, start, end);
1938            }
1939    
1940            /**
1941            * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63; and status = &#63;.
1942            *
1943            * <p>
1944            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1945            * </p>
1946            *
1947            * @param groupId the group ID
1948            * @param folderIds the folder IDs
1949            * @param status the status
1950            * @param start the lower bound of the range of bookmarks entries
1951            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1952            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1953            * @return the ordered range of matching bookmarks entries that the user has permission to view
1954            * @throws SystemException if a system exception occurred
1955            */
1956            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S(
1957                    long groupId, long[] folderIds, int status, int start, int end,
1958                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1959                    throws com.liferay.portal.kernel.exception.SystemException {
1960                    return getPersistence()
1961                                       .filterFindByG_F_S(groupId, folderIds, status, start, end,
1962                            orderByComparator);
1963            }
1964    
1965            /**
1966            * Returns all the bookmarks entries where groupId = &#63; and folderId = any &#63; and status = &#63;.
1967            *
1968            * <p>
1969            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1970            * </p>
1971            *
1972            * @param groupId the group ID
1973            * @param folderIds the folder IDs
1974            * @param status the status
1975            * @return the matching bookmarks entries
1976            * @throws SystemException if a system exception occurred
1977            */
1978            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S(
1979                    long groupId, long[] folderIds, int status)
1980                    throws com.liferay.portal.kernel.exception.SystemException {
1981                    return getPersistence().findByG_F_S(groupId, folderIds, status);
1982            }
1983    
1984            /**
1985            * Returns a range of all the bookmarks entries where groupId = &#63; and folderId = any &#63; and status = &#63;.
1986            *
1987            * <p>
1988            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1989            * </p>
1990            *
1991            * @param groupId the group ID
1992            * @param folderIds the folder IDs
1993            * @param status the status
1994            * @param start the lower bound of the range of bookmarks entries
1995            * @param end the upper bound of the range of bookmarks entries (not inclusive)
1996            * @return the range of matching bookmarks entries
1997            * @throws SystemException if a system exception occurred
1998            */
1999            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S(
2000                    long groupId, long[] folderIds, int status, int start, int end)
2001                    throws com.liferay.portal.kernel.exception.SystemException {
2002                    return getPersistence()
2003                                       .findByG_F_S(groupId, folderIds, status, start, end);
2004            }
2005    
2006            /**
2007            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and folderId = any &#63; and status = &#63;.
2008            *
2009            * <p>
2010            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2011            * </p>
2012            *
2013            * @param groupId the group ID
2014            * @param folderIds the folder IDs
2015            * @param status the status
2016            * @param start the lower bound of the range of bookmarks entries
2017            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2018            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2019            * @return the ordered range of matching bookmarks entries
2020            * @throws SystemException if a system exception occurred
2021            */
2022            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S(
2023                    long groupId, long[] folderIds, int status, int start, int end,
2024                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2025                    throws com.liferay.portal.kernel.exception.SystemException {
2026                    return getPersistence()
2027                                       .findByG_F_S(groupId, folderIds, status, start, end,
2028                            orderByComparator);
2029            }
2030    
2031            /**
2032            * Removes all the bookmarks entries where groupId = &#63; and folderId = &#63; and status = &#63; from the database.
2033            *
2034            * @param groupId the group ID
2035            * @param folderId the folder ID
2036            * @param status the status
2037            * @throws SystemException if a system exception occurred
2038            */
2039            public static void removeByG_F_S(long groupId, long folderId, int status)
2040                    throws com.liferay.portal.kernel.exception.SystemException {
2041                    getPersistence().removeByG_F_S(groupId, folderId, status);
2042            }
2043    
2044            /**
2045            * Returns the number of bookmarks entries where groupId = &#63; and folderId = &#63; and status = &#63;.
2046            *
2047            * @param groupId the group ID
2048            * @param folderId the folder ID
2049            * @param status the status
2050            * @return the number of matching bookmarks entries
2051            * @throws SystemException if a system exception occurred
2052            */
2053            public static int countByG_F_S(long groupId, long folderId, int status)
2054                    throws com.liferay.portal.kernel.exception.SystemException {
2055                    return getPersistence().countByG_F_S(groupId, folderId, status);
2056            }
2057    
2058            /**
2059            * Returns the number of bookmarks entries where groupId = &#63; and folderId = any &#63; and status = &#63;.
2060            *
2061            * @param groupId the group ID
2062            * @param folderIds the folder IDs
2063            * @param status the status
2064            * @return the number of matching bookmarks entries
2065            * @throws SystemException if a system exception occurred
2066            */
2067            public static int countByG_F_S(long groupId, long[] folderIds, int status)
2068                    throws com.liferay.portal.kernel.exception.SystemException {
2069                    return getPersistence().countByG_F_S(groupId, folderIds, status);
2070            }
2071    
2072            /**
2073            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63; and status = &#63;.
2074            *
2075            * @param groupId the group ID
2076            * @param folderId the folder ID
2077            * @param status the status
2078            * @return the number of matching bookmarks entries that the user has permission to view
2079            * @throws SystemException if a system exception occurred
2080            */
2081            public static int filterCountByG_F_S(long groupId, long folderId, int status)
2082                    throws com.liferay.portal.kernel.exception.SystemException {
2083                    return getPersistence().filterCountByG_F_S(groupId, folderId, status);
2084            }
2085    
2086            /**
2087            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63; and status = &#63;.
2088            *
2089            * @param groupId the group ID
2090            * @param folderIds the folder IDs
2091            * @param status the status
2092            * @return the number of matching bookmarks entries that the user has permission to view
2093            * @throws SystemException if a system exception occurred
2094            */
2095            public static int filterCountByG_F_S(long groupId, long[] folderIds,
2096                    int status) throws com.liferay.portal.kernel.exception.SystemException {
2097                    return getPersistence().filterCountByG_F_S(groupId, folderIds, status);
2098            }
2099    
2100            /**
2101            * Returns all the bookmarks entries where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2102            *
2103            * @param groupId the group ID
2104            * @param folderId the folder ID
2105            * @param status the status
2106            * @return the matching bookmarks entries
2107            * @throws SystemException if a system exception occurred
2108            */
2109            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS(
2110                    long groupId, long folderId, int status)
2111                    throws com.liferay.portal.kernel.exception.SystemException {
2112                    return getPersistence().findByG_F_NotS(groupId, folderId, status);
2113            }
2114    
2115            /**
2116            * Returns a range of all the bookmarks entries where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2117            *
2118            * <p>
2119            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2120            * </p>
2121            *
2122            * @param groupId the group ID
2123            * @param folderId the folder ID
2124            * @param status the status
2125            * @param start the lower bound of the range of bookmarks entries
2126            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2127            * @return the range of matching bookmarks entries
2128            * @throws SystemException if a system exception occurred
2129            */
2130            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS(
2131                    long groupId, long folderId, int status, int start, int end)
2132                    throws com.liferay.portal.kernel.exception.SystemException {
2133                    return getPersistence()
2134                                       .findByG_F_NotS(groupId, folderId, status, start, end);
2135            }
2136    
2137            /**
2138            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2139            *
2140            * <p>
2141            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2142            * </p>
2143            *
2144            * @param groupId the group ID
2145            * @param folderId the folder ID
2146            * @param status the status
2147            * @param start the lower bound of the range of bookmarks entries
2148            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2149            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2150            * @return the ordered range of matching bookmarks entries
2151            * @throws SystemException if a system exception occurred
2152            */
2153            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS(
2154                    long groupId, long folderId, int status, int start, int end,
2155                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2156                    throws com.liferay.portal.kernel.exception.SystemException {
2157                    return getPersistence()
2158                                       .findByG_F_NotS(groupId, folderId, status, start, end,
2159                            orderByComparator);
2160            }
2161    
2162            /**
2163            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2164            *
2165            * @param groupId the group ID
2166            * @param folderId the folder ID
2167            * @param status the status
2168            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2169            * @return the first matching bookmarks entry
2170            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
2171            * @throws SystemException if a system exception occurred
2172            */
2173            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_NotS_First(
2174                    long groupId, long folderId, int status,
2175                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2176                    throws com.liferay.portal.kernel.exception.SystemException,
2177                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2178                    return getPersistence()
2179                                       .findByG_F_NotS_First(groupId, folderId, status,
2180                            orderByComparator);
2181            }
2182    
2183            /**
2184            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2185            *
2186            * @param groupId the group ID
2187            * @param folderId the folder ID
2188            * @param status the status
2189            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2190            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
2191            * @throws SystemException if a system exception occurred
2192            */
2193            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_NotS_First(
2194                    long groupId, long folderId, int status,
2195                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2196                    throws com.liferay.portal.kernel.exception.SystemException {
2197                    return getPersistence()
2198                                       .fetchByG_F_NotS_First(groupId, folderId, status,
2199                            orderByComparator);
2200            }
2201    
2202            /**
2203            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2204            *
2205            * @param groupId the group ID
2206            * @param folderId the folder ID
2207            * @param status the status
2208            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2209            * @return the last matching bookmarks entry
2210            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
2211            * @throws SystemException if a system exception occurred
2212            */
2213            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_NotS_Last(
2214                    long groupId, long folderId, int status,
2215                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2216                    throws com.liferay.portal.kernel.exception.SystemException,
2217                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2218                    return getPersistence()
2219                                       .findByG_F_NotS_Last(groupId, folderId, status,
2220                            orderByComparator);
2221            }
2222    
2223            /**
2224            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2225            *
2226            * @param groupId the group ID
2227            * @param folderId the folder ID
2228            * @param status the status
2229            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2230            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
2231            * @throws SystemException if a system exception occurred
2232            */
2233            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_NotS_Last(
2234                    long groupId, long folderId, int status,
2235                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2236                    throws com.liferay.portal.kernel.exception.SystemException {
2237                    return getPersistence()
2238                                       .fetchByG_F_NotS_Last(groupId, folderId, status,
2239                            orderByComparator);
2240            }
2241    
2242            /**
2243            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2244            *
2245            * @param entryId the primary key of the current bookmarks entry
2246            * @param groupId the group ID
2247            * @param folderId the folder ID
2248            * @param status the status
2249            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2250            * @return the previous, current, and next bookmarks entry
2251            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
2252            * @throws SystemException if a system exception occurred
2253            */
2254            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_NotS_PrevAndNext(
2255                    long entryId, long groupId, long folderId, int status,
2256                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2257                    throws com.liferay.portal.kernel.exception.SystemException,
2258                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2259                    return getPersistence()
2260                                       .findByG_F_NotS_PrevAndNext(entryId, groupId, folderId,
2261                            status, orderByComparator);
2262            }
2263    
2264            /**
2265            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2266            *
2267            * @param groupId the group ID
2268            * @param folderId the folder ID
2269            * @param status the status
2270            * @return the matching bookmarks entries that the user has permission to view
2271            * @throws SystemException if a system exception occurred
2272            */
2273            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS(
2274                    long groupId, long folderId, int status)
2275                    throws com.liferay.portal.kernel.exception.SystemException {
2276                    return getPersistence().filterFindByG_F_NotS(groupId, folderId, status);
2277            }
2278    
2279            /**
2280            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2281            *
2282            * <p>
2283            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2284            * </p>
2285            *
2286            * @param groupId the group ID
2287            * @param folderId the folder ID
2288            * @param status the status
2289            * @param start the lower bound of the range of bookmarks entries
2290            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2291            * @return the range of matching bookmarks entries that the user has permission to view
2292            * @throws SystemException if a system exception occurred
2293            */
2294            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS(
2295                    long groupId, long folderId, int status, int start, int end)
2296                    throws com.liferay.portal.kernel.exception.SystemException {
2297                    return getPersistence()
2298                                       .filterFindByG_F_NotS(groupId, folderId, status, start, end);
2299            }
2300    
2301            /**
2302            * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2303            *
2304            * <p>
2305            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2306            * </p>
2307            *
2308            * @param groupId the group ID
2309            * @param folderId the folder ID
2310            * @param status the status
2311            * @param start the lower bound of the range of bookmarks entries
2312            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2313            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2314            * @return the ordered range of matching bookmarks entries that the user has permission to view
2315            * @throws SystemException if a system exception occurred
2316            */
2317            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS(
2318                    long groupId, long folderId, int status, int start, int end,
2319                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2320                    throws com.liferay.portal.kernel.exception.SystemException {
2321                    return getPersistence()
2322                                       .filterFindByG_F_NotS(groupId, folderId, status, start, end,
2323                            orderByComparator);
2324            }
2325    
2326            /**
2327            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2328            *
2329            * @param entryId the primary key of the current bookmarks entry
2330            * @param groupId the group ID
2331            * @param folderId the folder ID
2332            * @param status the status
2333            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2334            * @return the previous, current, and next bookmarks entry
2335            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
2336            * @throws SystemException if a system exception occurred
2337            */
2338            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_NotS_PrevAndNext(
2339                    long entryId, long groupId, long folderId, int status,
2340                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2341                    throws com.liferay.portal.kernel.exception.SystemException,
2342                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2343                    return getPersistence()
2344                                       .filterFindByG_F_NotS_PrevAndNext(entryId, groupId,
2345                            folderId, status, orderByComparator);
2346            }
2347    
2348            /**
2349            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63; and status &ne; &#63;.
2350            *
2351            * @param groupId the group ID
2352            * @param folderIds the folder IDs
2353            * @param status the status
2354            * @return the matching bookmarks entries that the user has permission to view
2355            * @throws SystemException if a system exception occurred
2356            */
2357            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS(
2358                    long groupId, long[] folderIds, int status)
2359                    throws com.liferay.portal.kernel.exception.SystemException {
2360                    return getPersistence().filterFindByG_F_NotS(groupId, folderIds, status);
2361            }
2362    
2363            /**
2364            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63; and status &ne; &#63;.
2365            *
2366            * <p>
2367            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2368            * </p>
2369            *
2370            * @param groupId the group ID
2371            * @param folderIds the folder IDs
2372            * @param status the status
2373            * @param start the lower bound of the range of bookmarks entries
2374            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2375            * @return the range of matching bookmarks entries that the user has permission to view
2376            * @throws SystemException if a system exception occurred
2377            */
2378            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS(
2379                    long groupId, long[] folderIds, int status, int start, int end)
2380                    throws com.liferay.portal.kernel.exception.SystemException {
2381                    return getPersistence()
2382                                       .filterFindByG_F_NotS(groupId, folderIds, status, start, end);
2383            }
2384    
2385            /**
2386            * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63; and status &ne; &#63;.
2387            *
2388            * <p>
2389            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2390            * </p>
2391            *
2392            * @param groupId the group ID
2393            * @param folderIds the folder IDs
2394            * @param status the status
2395            * @param start the lower bound of the range of bookmarks entries
2396            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2397            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2398            * @return the ordered range of matching bookmarks entries that the user has permission to view
2399            * @throws SystemException if a system exception occurred
2400            */
2401            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_NotS(
2402                    long groupId, long[] folderIds, int status, int start, int end,
2403                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2404                    throws com.liferay.portal.kernel.exception.SystemException {
2405                    return getPersistence()
2406                                       .filterFindByG_F_NotS(groupId, folderIds, status, start,
2407                            end, orderByComparator);
2408            }
2409    
2410            /**
2411            * Returns all the bookmarks entries where groupId = &#63; and folderId = any &#63; and status &ne; &#63;.
2412            *
2413            * <p>
2414            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2415            * </p>
2416            *
2417            * @param groupId the group ID
2418            * @param folderIds the folder IDs
2419            * @param status the status
2420            * @return the matching bookmarks entries
2421            * @throws SystemException if a system exception occurred
2422            */
2423            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS(
2424                    long groupId, long[] folderIds, int status)
2425                    throws com.liferay.portal.kernel.exception.SystemException {
2426                    return getPersistence().findByG_F_NotS(groupId, folderIds, status);
2427            }
2428    
2429            /**
2430            * Returns a range of all the bookmarks entries where groupId = &#63; and folderId = any &#63; and status &ne; &#63;.
2431            *
2432            * <p>
2433            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2434            * </p>
2435            *
2436            * @param groupId the group ID
2437            * @param folderIds the folder IDs
2438            * @param status the status
2439            * @param start the lower bound of the range of bookmarks entries
2440            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2441            * @return the range of matching bookmarks entries
2442            * @throws SystemException if a system exception occurred
2443            */
2444            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS(
2445                    long groupId, long[] folderIds, int status, int start, int end)
2446                    throws com.liferay.portal.kernel.exception.SystemException {
2447                    return getPersistence()
2448                                       .findByG_F_NotS(groupId, folderIds, status, start, end);
2449            }
2450    
2451            /**
2452            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and folderId = any &#63; and status &ne; &#63;.
2453            *
2454            * <p>
2455            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2456            * </p>
2457            *
2458            * @param groupId the group ID
2459            * @param folderIds the folder IDs
2460            * @param status the status
2461            * @param start the lower bound of the range of bookmarks entries
2462            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2463            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2464            * @return the ordered range of matching bookmarks entries
2465            * @throws SystemException if a system exception occurred
2466            */
2467            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_NotS(
2468                    long groupId, long[] folderIds, int status, int start, int end,
2469                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2470                    throws com.liferay.portal.kernel.exception.SystemException {
2471                    return getPersistence()
2472                                       .findByG_F_NotS(groupId, folderIds, status, start, end,
2473                            orderByComparator);
2474            }
2475    
2476            /**
2477            * Removes all the bookmarks entries where groupId = &#63; and folderId = &#63; and status &ne; &#63; from the database.
2478            *
2479            * @param groupId the group ID
2480            * @param folderId the folder ID
2481            * @param status the status
2482            * @throws SystemException if a system exception occurred
2483            */
2484            public static void removeByG_F_NotS(long groupId, long folderId, int status)
2485                    throws com.liferay.portal.kernel.exception.SystemException {
2486                    getPersistence().removeByG_F_NotS(groupId, folderId, status);
2487            }
2488    
2489            /**
2490            * Returns the number of bookmarks entries where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2491            *
2492            * @param groupId the group ID
2493            * @param folderId the folder ID
2494            * @param status the status
2495            * @return the number of matching bookmarks entries
2496            * @throws SystemException if a system exception occurred
2497            */
2498            public static int countByG_F_NotS(long groupId, long folderId, int status)
2499                    throws com.liferay.portal.kernel.exception.SystemException {
2500                    return getPersistence().countByG_F_NotS(groupId, folderId, status);
2501            }
2502    
2503            /**
2504            * Returns the number of bookmarks entries where groupId = &#63; and folderId = any &#63; and status &ne; &#63;.
2505            *
2506            * @param groupId the group ID
2507            * @param folderIds the folder IDs
2508            * @param status the status
2509            * @return the number of matching bookmarks entries
2510            * @throws SystemException if a system exception occurred
2511            */
2512            public static int countByG_F_NotS(long groupId, long[] folderIds, int status)
2513                    throws com.liferay.portal.kernel.exception.SystemException {
2514                    return getPersistence().countByG_F_NotS(groupId, folderIds, status);
2515            }
2516    
2517            /**
2518            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = &#63; and status &ne; &#63;.
2519            *
2520            * @param groupId the group ID
2521            * @param folderId the folder ID
2522            * @param status the status
2523            * @return the number of matching bookmarks entries that the user has permission to view
2524            * @throws SystemException if a system exception occurred
2525            */
2526            public static int filterCountByG_F_NotS(long groupId, long folderId,
2527                    int status) throws com.liferay.portal.kernel.exception.SystemException {
2528                    return getPersistence().filterCountByG_F_NotS(groupId, folderId, status);
2529            }
2530    
2531            /**
2532            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and folderId = any &#63; and status &ne; &#63;.
2533            *
2534            * @param groupId the group ID
2535            * @param folderIds the folder IDs
2536            * @param status the status
2537            * @return the number of matching bookmarks entries that the user has permission to view
2538            * @throws SystemException if a system exception occurred
2539            */
2540            public static int filterCountByG_F_NotS(long groupId, long[] folderIds,
2541                    int status) throws com.liferay.portal.kernel.exception.SystemException {
2542                    return getPersistence().filterCountByG_F_NotS(groupId, folderIds, status);
2543            }
2544    
2545            /**
2546            * Returns all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2547            *
2548            * @param groupId the group ID
2549            * @param userId the user ID
2550            * @param folderId the folder ID
2551            * @param status the status
2552            * @return the matching bookmarks entries
2553            * @throws SystemException if a system exception occurred
2554            */
2555            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S(
2556                    long groupId, long userId, long folderId, int status)
2557                    throws com.liferay.portal.kernel.exception.SystemException {
2558                    return getPersistence().findByG_U_F_S(groupId, userId, folderId, status);
2559            }
2560    
2561            /**
2562            * Returns a range of all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2563            *
2564            * <p>
2565            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2566            * </p>
2567            *
2568            * @param groupId the group ID
2569            * @param userId the user ID
2570            * @param folderId the folder ID
2571            * @param status the status
2572            * @param start the lower bound of the range of bookmarks entries
2573            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2574            * @return the range of matching bookmarks entries
2575            * @throws SystemException if a system exception occurred
2576            */
2577            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S(
2578                    long groupId, long userId, long folderId, int status, int start, int end)
2579                    throws com.liferay.portal.kernel.exception.SystemException {
2580                    return getPersistence()
2581                                       .findByG_U_F_S(groupId, userId, folderId, status, start, end);
2582            }
2583    
2584            /**
2585            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2586            *
2587            * <p>
2588            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2589            * </p>
2590            *
2591            * @param groupId the group ID
2592            * @param userId the user ID
2593            * @param folderId the folder ID
2594            * @param status the status
2595            * @param start the lower bound of the range of bookmarks entries
2596            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2597            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2598            * @return the ordered range of matching bookmarks entries
2599            * @throws SystemException if a system exception occurred
2600            */
2601            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S(
2602                    long groupId, long userId, long folderId, int status, int start,
2603                    int end,
2604                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2605                    throws com.liferay.portal.kernel.exception.SystemException {
2606                    return getPersistence()
2607                                       .findByG_U_F_S(groupId, userId, folderId, status, start,
2608                            end, orderByComparator);
2609            }
2610    
2611            /**
2612            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2613            *
2614            * @param groupId the group ID
2615            * @param userId the user ID
2616            * @param folderId the folder ID
2617            * @param status the status
2618            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2619            * @return the first matching bookmarks entry
2620            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
2621            * @throws SystemException if a system exception occurred
2622            */
2623            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_F_S_First(
2624                    long groupId, long userId, long folderId, int status,
2625                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2626                    throws com.liferay.portal.kernel.exception.SystemException,
2627                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2628                    return getPersistence()
2629                                       .findByG_U_F_S_First(groupId, userId, folderId, status,
2630                            orderByComparator);
2631            }
2632    
2633            /**
2634            * Returns the first bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2635            *
2636            * @param groupId the group ID
2637            * @param userId the user ID
2638            * @param folderId the folder ID
2639            * @param status the status
2640            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2641            * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
2642            * @throws SystemException if a system exception occurred
2643            */
2644            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_F_S_First(
2645                    long groupId, long userId, long folderId, int status,
2646                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2647                    throws com.liferay.portal.kernel.exception.SystemException {
2648                    return getPersistence()
2649                                       .fetchByG_U_F_S_First(groupId, userId, folderId, status,
2650                            orderByComparator);
2651            }
2652    
2653            /**
2654            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2655            *
2656            * @param groupId the group ID
2657            * @param userId the user ID
2658            * @param folderId the folder ID
2659            * @param status the status
2660            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2661            * @return the last matching bookmarks entry
2662            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found
2663            * @throws SystemException if a system exception occurred
2664            */
2665            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_F_S_Last(
2666                    long groupId, long userId, long folderId, int status,
2667                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2668                    throws com.liferay.portal.kernel.exception.SystemException,
2669                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2670                    return getPersistence()
2671                                       .findByG_U_F_S_Last(groupId, userId, folderId, status,
2672                            orderByComparator);
2673            }
2674    
2675            /**
2676            * Returns the last bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2677            *
2678            * @param groupId the group ID
2679            * @param userId the user ID
2680            * @param folderId the folder ID
2681            * @param status the status
2682            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2683            * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found
2684            * @throws SystemException if a system exception occurred
2685            */
2686            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_F_S_Last(
2687                    long groupId, long userId, long folderId, int status,
2688                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2689                    throws com.liferay.portal.kernel.exception.SystemException {
2690                    return getPersistence()
2691                                       .fetchByG_U_F_S_Last(groupId, userId, folderId, status,
2692                            orderByComparator);
2693            }
2694    
2695            /**
2696            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2697            *
2698            * @param entryId the primary key of the current bookmarks entry
2699            * @param groupId the group ID
2700            * @param userId the user ID
2701            * @param folderId the folder ID
2702            * @param status the status
2703            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2704            * @return the previous, current, and next bookmarks entry
2705            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
2706            * @throws SystemException if a system exception occurred
2707            */
2708            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_U_F_S_PrevAndNext(
2709                    long entryId, long groupId, long userId, long folderId, int status,
2710                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2711                    throws com.liferay.portal.kernel.exception.SystemException,
2712                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2713                    return getPersistence()
2714                                       .findByG_U_F_S_PrevAndNext(entryId, groupId, userId,
2715                            folderId, status, orderByComparator);
2716            }
2717    
2718            /**
2719            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2720            *
2721            * @param groupId the group ID
2722            * @param userId the user ID
2723            * @param folderId the folder ID
2724            * @param status the status
2725            * @return the matching bookmarks entries that the user has permission to view
2726            * @throws SystemException if a system exception occurred
2727            */
2728            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S(
2729                    long groupId, long userId, long folderId, int status)
2730                    throws com.liferay.portal.kernel.exception.SystemException {
2731                    return getPersistence()
2732                                       .filterFindByG_U_F_S(groupId, userId, folderId, status);
2733            }
2734    
2735            /**
2736            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2737            *
2738            * <p>
2739            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2740            * </p>
2741            *
2742            * @param groupId the group ID
2743            * @param userId the user ID
2744            * @param folderId the folder ID
2745            * @param status the status
2746            * @param start the lower bound of the range of bookmarks entries
2747            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2748            * @return the range of matching bookmarks entries that the user has permission to view
2749            * @throws SystemException if a system exception occurred
2750            */
2751            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S(
2752                    long groupId, long userId, long folderId, int status, int start, int end)
2753                    throws com.liferay.portal.kernel.exception.SystemException {
2754                    return getPersistence()
2755                                       .filterFindByG_U_F_S(groupId, userId, folderId, status,
2756                            start, end);
2757            }
2758    
2759            /**
2760            * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2761            *
2762            * <p>
2763            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2764            * </p>
2765            *
2766            * @param groupId the group ID
2767            * @param userId the user ID
2768            * @param folderId the folder ID
2769            * @param status the status
2770            * @param start the lower bound of the range of bookmarks entries
2771            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2772            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2773            * @return the ordered range of matching bookmarks entries that the user has permission to view
2774            * @throws SystemException if a system exception occurred
2775            */
2776            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S(
2777                    long groupId, long userId, long folderId, int status, int start,
2778                    int end,
2779                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2780                    throws com.liferay.portal.kernel.exception.SystemException {
2781                    return getPersistence()
2782                                       .filterFindByG_U_F_S(groupId, userId, folderId, status,
2783                            start, end, orderByComparator);
2784            }
2785    
2786            /**
2787            * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set of bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2788            *
2789            * @param entryId the primary key of the current bookmarks entry
2790            * @param groupId the group ID
2791            * @param userId the user ID
2792            * @param folderId the folder ID
2793            * @param status the status
2794            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2795            * @return the previous, current, and next bookmarks entry
2796            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
2797            * @throws SystemException if a system exception occurred
2798            */
2799            public static com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_U_F_S_PrevAndNext(
2800                    long entryId, long groupId, long userId, long folderId, int status,
2801                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2802                    throws com.liferay.portal.kernel.exception.SystemException,
2803                            com.liferay.portlet.bookmarks.NoSuchEntryException {
2804                    return getPersistence()
2805                                       .filterFindByG_U_F_S_PrevAndNext(entryId, groupId, userId,
2806                            folderId, status, orderByComparator);
2807            }
2808    
2809            /**
2810            * Returns all the bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and folderId = any &#63; and status = &#63;.
2811            *
2812            * @param groupId the group ID
2813            * @param userId the user ID
2814            * @param folderIds the folder IDs
2815            * @param status the status
2816            * @return the matching bookmarks entries that the user has permission to view
2817            * @throws SystemException if a system exception occurred
2818            */
2819            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S(
2820                    long groupId, long userId, long[] folderIds, int status)
2821                    throws com.liferay.portal.kernel.exception.SystemException {
2822                    return getPersistence()
2823                                       .filterFindByG_U_F_S(groupId, userId, folderIds, status);
2824            }
2825    
2826            /**
2827            * Returns a range of all the bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and folderId = any &#63; and status = &#63;.
2828            *
2829            * <p>
2830            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2831            * </p>
2832            *
2833            * @param groupId the group ID
2834            * @param userId the user ID
2835            * @param folderIds the folder IDs
2836            * @param status the status
2837            * @param start the lower bound of the range of bookmarks entries
2838            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2839            * @return the range of matching bookmarks entries that the user has permission to view
2840            * @throws SystemException if a system exception occurred
2841            */
2842            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S(
2843                    long groupId, long userId, long[] folderIds, int status, int start,
2844                    int end) throws com.liferay.portal.kernel.exception.SystemException {
2845                    return getPersistence()
2846                                       .filterFindByG_U_F_S(groupId, userId, folderIds, status,
2847                            start, end);
2848            }
2849    
2850            /**
2851            * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and folderId = any &#63; and status = &#63;.
2852            *
2853            * <p>
2854            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2855            * </p>
2856            *
2857            * @param groupId the group ID
2858            * @param userId the user ID
2859            * @param folderIds the folder IDs
2860            * @param status the status
2861            * @param start the lower bound of the range of bookmarks entries
2862            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2863            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2864            * @return the ordered range of matching bookmarks entries that the user has permission to view
2865            * @throws SystemException if a system exception occurred
2866            */
2867            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S(
2868                    long groupId, long userId, long[] folderIds, int status, int start,
2869                    int end,
2870                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2871                    throws com.liferay.portal.kernel.exception.SystemException {
2872                    return getPersistence()
2873                                       .filterFindByG_U_F_S(groupId, userId, folderIds, status,
2874                            start, end, orderByComparator);
2875            }
2876    
2877            /**
2878            * Returns all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = any &#63; and status = &#63;.
2879            *
2880            * <p>
2881            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2882            * </p>
2883            *
2884            * @param groupId the group ID
2885            * @param userId the user ID
2886            * @param folderIds the folder IDs
2887            * @param status the status
2888            * @return the matching bookmarks entries
2889            * @throws SystemException if a system exception occurred
2890            */
2891            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S(
2892                    long groupId, long userId, long[] folderIds, int status)
2893                    throws com.liferay.portal.kernel.exception.SystemException {
2894                    return getPersistence().findByG_U_F_S(groupId, userId, folderIds, status);
2895            }
2896    
2897            /**
2898            * Returns a range of all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = any &#63; and status = &#63;.
2899            *
2900            * <p>
2901            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2902            * </p>
2903            *
2904            * @param groupId the group ID
2905            * @param userId the user ID
2906            * @param folderIds the folder IDs
2907            * @param status the status
2908            * @param start the lower bound of the range of bookmarks entries
2909            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2910            * @return the range of matching bookmarks entries
2911            * @throws SystemException if a system exception occurred
2912            */
2913            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S(
2914                    long groupId, long userId, long[] folderIds, int status, int start,
2915                    int end) throws com.liferay.portal.kernel.exception.SystemException {
2916                    return getPersistence()
2917                                       .findByG_U_F_S(groupId, userId, folderIds, status, start, end);
2918            }
2919    
2920            /**
2921            * Returns an ordered range of all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = any &#63; and status = &#63;.
2922            *
2923            * <p>
2924            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2925            * </p>
2926            *
2927            * @param groupId the group ID
2928            * @param userId the user ID
2929            * @param folderIds the folder IDs
2930            * @param status the status
2931            * @param start the lower bound of the range of bookmarks entries
2932            * @param end the upper bound of the range of bookmarks entries (not inclusive)
2933            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2934            * @return the ordered range of matching bookmarks entries
2935            * @throws SystemException if a system exception occurred
2936            */
2937            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S(
2938                    long groupId, long userId, long[] folderIds, int status, int start,
2939                    int end,
2940                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2941                    throws com.liferay.portal.kernel.exception.SystemException {
2942                    return getPersistence()
2943                                       .findByG_U_F_S(groupId, userId, folderIds, status, start,
2944                            end, orderByComparator);
2945            }
2946    
2947            /**
2948            * Removes all the bookmarks entries where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63; from the database.
2949            *
2950            * @param groupId the group ID
2951            * @param userId the user ID
2952            * @param folderId the folder ID
2953            * @param status the status
2954            * @throws SystemException if a system exception occurred
2955            */
2956            public static void removeByG_U_F_S(long groupId, long userId,
2957                    long folderId, int status)
2958                    throws com.liferay.portal.kernel.exception.SystemException {
2959                    getPersistence().removeByG_U_F_S(groupId, userId, folderId, status);
2960            }
2961    
2962            /**
2963            * Returns the number of bookmarks entries where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2964            *
2965            * @param groupId the group ID
2966            * @param userId the user ID
2967            * @param folderId the folder ID
2968            * @param status the status
2969            * @return the number of matching bookmarks entries
2970            * @throws SystemException if a system exception occurred
2971            */
2972            public static int countByG_U_F_S(long groupId, long userId, long folderId,
2973                    int status) throws com.liferay.portal.kernel.exception.SystemException {
2974                    return getPersistence().countByG_U_F_S(groupId, userId, folderId, status);
2975            }
2976    
2977            /**
2978            * Returns the number of bookmarks entries where groupId = &#63; and userId = &#63; and folderId = any &#63; and status = &#63;.
2979            *
2980            * @param groupId the group ID
2981            * @param userId the user ID
2982            * @param folderIds the folder IDs
2983            * @param status the status
2984            * @return the number of matching bookmarks entries
2985            * @throws SystemException if a system exception occurred
2986            */
2987            public static int countByG_U_F_S(long groupId, long userId,
2988                    long[] folderIds, int status)
2989                    throws com.liferay.portal.kernel.exception.SystemException {
2990                    return getPersistence()
2991                                       .countByG_U_F_S(groupId, userId, folderIds, status);
2992            }
2993    
2994            /**
2995            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and folderId = &#63; and status = &#63;.
2996            *
2997            * @param groupId the group ID
2998            * @param userId the user ID
2999            * @param folderId the folder ID
3000            * @param status the status
3001            * @return the number of matching bookmarks entries that the user has permission to view
3002            * @throws SystemException if a system exception occurred
3003            */
3004            public static int filterCountByG_U_F_S(long groupId, long userId,
3005                    long folderId, int status)
3006                    throws com.liferay.portal.kernel.exception.SystemException {
3007                    return getPersistence()
3008                                       .filterCountByG_U_F_S(groupId, userId, folderId, status);
3009            }
3010    
3011            /**
3012            * Returns the number of bookmarks entries that the user has permission to view where groupId = &#63; and userId = &#63; and folderId = any &#63; and status = &#63;.
3013            *
3014            * @param groupId the group ID
3015            * @param userId the user ID
3016            * @param folderIds the folder IDs
3017            * @param status the status
3018            * @return the number of matching bookmarks entries that the user has permission to view
3019            * @throws SystemException if a system exception occurred
3020            */
3021            public static int filterCountByG_U_F_S(long groupId, long userId,
3022                    long[] folderIds, int status)
3023                    throws com.liferay.portal.kernel.exception.SystemException {
3024                    return getPersistence()
3025                                       .filterCountByG_U_F_S(groupId, userId, folderIds, status);
3026            }
3027    
3028            /**
3029            * Caches the bookmarks entry in the entity cache if it is enabled.
3030            *
3031            * @param bookmarksEntry the bookmarks entry
3032            */
3033            public static void cacheResult(
3034                    com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry) {
3035                    getPersistence().cacheResult(bookmarksEntry);
3036            }
3037    
3038            /**
3039            * Caches the bookmarks entries in the entity cache if it is enabled.
3040            *
3041            * @param bookmarksEntries the bookmarks entries
3042            */
3043            public static void cacheResult(
3044                    java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> bookmarksEntries) {
3045                    getPersistence().cacheResult(bookmarksEntries);
3046            }
3047    
3048            /**
3049            * Creates a new bookmarks entry with the primary key. Does not add the bookmarks entry to the database.
3050            *
3051            * @param entryId the primary key for the new bookmarks entry
3052            * @return the new bookmarks entry
3053            */
3054            public static com.liferay.portlet.bookmarks.model.BookmarksEntry create(
3055                    long entryId) {
3056                    return getPersistence().create(entryId);
3057            }
3058    
3059            /**
3060            * Removes the bookmarks entry with the primary key from the database. Also notifies the appropriate model listeners.
3061            *
3062            * @param entryId the primary key of the bookmarks entry
3063            * @return the bookmarks entry that was removed
3064            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
3065            * @throws SystemException if a system exception occurred
3066            */
3067            public static com.liferay.portlet.bookmarks.model.BookmarksEntry remove(
3068                    long entryId)
3069                    throws com.liferay.portal.kernel.exception.SystemException,
3070                            com.liferay.portlet.bookmarks.NoSuchEntryException {
3071                    return getPersistence().remove(entryId);
3072            }
3073    
3074            public static com.liferay.portlet.bookmarks.model.BookmarksEntry updateImpl(
3075                    com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry)
3076                    throws com.liferay.portal.kernel.exception.SystemException {
3077                    return getPersistence().updateImpl(bookmarksEntry);
3078            }
3079    
3080            /**
3081            * Returns the bookmarks entry with the primary key or throws a {@link com.liferay.portlet.bookmarks.NoSuchEntryException} if it could not be found.
3082            *
3083            * @param entryId the primary key of the bookmarks entry
3084            * @return the bookmarks entry
3085            * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found
3086            * @throws SystemException if a system exception occurred
3087            */
3088            public static com.liferay.portlet.bookmarks.model.BookmarksEntry findByPrimaryKey(
3089                    long entryId)
3090                    throws com.liferay.portal.kernel.exception.SystemException,
3091                            com.liferay.portlet.bookmarks.NoSuchEntryException {
3092                    return getPersistence().findByPrimaryKey(entryId);
3093            }
3094    
3095            /**
3096            * Returns the bookmarks entry with the primary key or returns <code>null</code> if it could not be found.
3097            *
3098            * @param entryId the primary key of the bookmarks entry
3099            * @return the bookmarks entry, or <code>null</code> if a bookmarks entry with the primary key could not be found
3100            * @throws SystemException if a system exception occurred
3101            */
3102            public static com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByPrimaryKey(
3103                    long entryId)
3104                    throws com.liferay.portal.kernel.exception.SystemException {
3105                    return getPersistence().fetchByPrimaryKey(entryId);
3106            }
3107    
3108            /**
3109            * Returns all the bookmarks entries.
3110            *
3111            * @return the bookmarks entries
3112            * @throws SystemException if a system exception occurred
3113            */
3114            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll()
3115                    throws com.liferay.portal.kernel.exception.SystemException {
3116                    return getPersistence().findAll();
3117            }
3118    
3119            /**
3120            * Returns a range of all the bookmarks entries.
3121            *
3122            * <p>
3123            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3124            * </p>
3125            *
3126            * @param start the lower bound of the range of bookmarks entries
3127            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3128            * @return the range of bookmarks entries
3129            * @throws SystemException if a system exception occurred
3130            */
3131            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll(
3132                    int start, int end)
3133                    throws com.liferay.portal.kernel.exception.SystemException {
3134                    return getPersistence().findAll(start, end);
3135            }
3136    
3137            /**
3138            * Returns an ordered range of all the bookmarks entries.
3139            *
3140            * <p>
3141            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3142            * </p>
3143            *
3144            * @param start the lower bound of the range of bookmarks entries
3145            * @param end the upper bound of the range of bookmarks entries (not inclusive)
3146            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3147            * @return the ordered range of bookmarks entries
3148            * @throws SystemException if a system exception occurred
3149            */
3150            public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll(
3151                    int start, int end,
3152                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3153                    throws com.liferay.portal.kernel.exception.SystemException {
3154                    return getPersistence().findAll(start, end, orderByComparator);
3155            }
3156    
3157            /**
3158            * Removes all the bookmarks entries from the database.
3159            *
3160            * @throws SystemException if a system exception occurred
3161            */
3162            public static void removeAll()
3163                    throws com.liferay.portal.kernel.exception.SystemException {
3164                    getPersistence().removeAll();
3165            }
3166    
3167            /**
3168            * Returns the number of bookmarks entries.
3169            *
3170            * @return the number of bookmarks entries
3171            * @throws SystemException if a system exception occurred
3172            */
3173            public static int countAll()
3174                    throws com.liferay.portal.kernel.exception.SystemException {
3175                    return getPersistence().countAll();
3176            }
3177    
3178            public static BookmarksEntryPersistence getPersistence() {
3179                    if (_persistence == null) {
3180                            _persistence = (BookmarksEntryPersistence)PortalBeanLocatorUtil.locate(BookmarksEntryPersistence.class.getName());
3181    
3182                            ReferenceRegistry.registerReference(BookmarksEntryUtil.class,
3183                                    "_persistence");
3184                    }
3185    
3186                    return _persistence;
3187            }
3188    
3189            /**
3190             * @deprecated As of 6.2.0
3191             */
3192            public void setPersistence(BookmarksEntryPersistence persistence) {
3193            }
3194    
3195            private static BookmarksEntryPersistence _persistence;
3196    }