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