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