001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.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 static long countWithDynamicQuery(DynamicQuery dynamicQuery)
065                    throws SystemException {
066                    return getPersistence().countWithDynamicQuery(dynamicQuery);
067            }
068    
069            /**
070             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
071             */
072            public static List<BlogsEntry> findWithDynamicQuery(
073                    DynamicQuery dynamicQuery) throws SystemException {
074                    return getPersistence().findWithDynamicQuery(dynamicQuery);
075            }
076    
077            /**
078             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
079             */
080            public static List<BlogsEntry> findWithDynamicQuery(
081                    DynamicQuery dynamicQuery, int start, int end)
082                    throws SystemException {
083                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
084            }
085    
086            /**
087             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
088             */
089            public static List<BlogsEntry> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator orderByComparator) throws SystemException {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
099             */
100            public static BlogsEntry update(BlogsEntry blogsEntry)
101                    throws SystemException {
102                    return getPersistence().update(blogsEntry);
103            }
104    
105            /**
106             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
107             */
108            public static BlogsEntry update(BlogsEntry blogsEntry,
109                    ServiceContext serviceContext) throws SystemException {
110                    return getPersistence().update(blogsEntry, serviceContext);
111            }
112    
113            /**
114            * Returns all the blogs entries where uuid = &#63;.
115            *
116            * @param uuid the uuid
117            * @return the matching blogs entries
118            * @throws SystemException if a system exception occurred
119            */
120            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByUuid(
121                    java.lang.String uuid)
122                    throws com.liferay.portal.kernel.exception.SystemException {
123                    return getPersistence().findByUuid(uuid);
124            }
125    
126            /**
127            * Returns a range of all the blogs entries where uuid = &#63;.
128            *
129            * <p>
130            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
131            * </p>
132            *
133            * @param uuid the uuid
134            * @param start the lower bound of the range of blogs entries
135            * @param end the upper bound of the range of blogs entries (not inclusive)
136            * @return the range of matching blogs entries
137            * @throws SystemException if a system exception occurred
138            */
139            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByUuid(
140                    java.lang.String uuid, int start, int end)
141                    throws com.liferay.portal.kernel.exception.SystemException {
142                    return getPersistence().findByUuid(uuid, start, end);
143            }
144    
145            /**
146            * Returns an ordered range of all the blogs entries where uuid = &#63;.
147            *
148            * <p>
149            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
150            * </p>
151            *
152            * @param uuid the uuid
153            * @param start the lower bound of the range of blogs entries
154            * @param end the upper bound of the range of blogs entries (not inclusive)
155            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
156            * @return the ordered range of matching blogs entries
157            * @throws SystemException if a system exception occurred
158            */
159            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByUuid(
160                    java.lang.String uuid, int start, int end,
161                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
162                    throws com.liferay.portal.kernel.exception.SystemException {
163                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
164            }
165    
166            /**
167            * Returns the first blogs entry in the ordered set where uuid = &#63;.
168            *
169            * @param uuid the uuid
170            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
171            * @return the first matching blogs entry
172            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
173            * @throws SystemException if a system exception occurred
174            */
175            public static com.liferay.portlet.blogs.model.BlogsEntry findByUuid_First(
176                    java.lang.String uuid,
177                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
178                    throws com.liferay.portal.kernel.exception.SystemException,
179                            com.liferay.portlet.blogs.NoSuchEntryException {
180                    return getPersistence().findByUuid_First(uuid, orderByComparator);
181            }
182    
183            /**
184            * Returns the first blogs entry in the ordered set where uuid = &#63;.
185            *
186            * @param uuid the uuid
187            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
188            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
189            * @throws SystemException if a system exception occurred
190            */
191            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByUuid_First(
192                    java.lang.String uuid,
193                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
194                    throws com.liferay.portal.kernel.exception.SystemException {
195                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
196            }
197    
198            /**
199            * Returns the last blogs entry in the ordered set where uuid = &#63;.
200            *
201            * @param uuid the uuid
202            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
203            * @return the last matching blogs entry
204            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
205            * @throws SystemException if a system exception occurred
206            */
207            public static com.liferay.portlet.blogs.model.BlogsEntry findByUuid_Last(
208                    java.lang.String uuid,
209                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
210                    throws com.liferay.portal.kernel.exception.SystemException,
211                            com.liferay.portlet.blogs.NoSuchEntryException {
212                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
213            }
214    
215            /**
216            * Returns the last blogs entry in the ordered set where uuid = &#63;.
217            *
218            * @param uuid the uuid
219            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
220            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
221            * @throws SystemException if a system exception occurred
222            */
223            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByUuid_Last(
224                    java.lang.String uuid,
225                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
226                    throws com.liferay.portal.kernel.exception.SystemException {
227                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
228            }
229    
230            /**
231            * Returns the blogs entries before and after the current blogs entry in the ordered set where uuid = &#63;.
232            *
233            * @param entryId the primary key of the current blogs entry
234            * @param uuid the uuid
235            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
236            * @return the previous, current, and next blogs entry
237            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
238            * @throws SystemException if a system exception occurred
239            */
240            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByUuid_PrevAndNext(
241                    long entryId, java.lang.String uuid,
242                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
243                    throws com.liferay.portal.kernel.exception.SystemException,
244                            com.liferay.portlet.blogs.NoSuchEntryException {
245                    return getPersistence()
246                                       .findByUuid_PrevAndNext(entryId, uuid, orderByComparator);
247            }
248    
249            /**
250            * Removes all the blogs entries where uuid = &#63; from the database.
251            *
252            * @param uuid the uuid
253            * @throws SystemException if a system exception occurred
254            */
255            public static void removeByUuid(java.lang.String uuid)
256                    throws com.liferay.portal.kernel.exception.SystemException {
257                    getPersistence().removeByUuid(uuid);
258            }
259    
260            /**
261            * Returns the number of blogs entries where uuid = &#63;.
262            *
263            * @param uuid the uuid
264            * @return the number of matching blogs entries
265            * @throws SystemException if a system exception occurred
266            */
267            public static int countByUuid(java.lang.String uuid)
268                    throws com.liferay.portal.kernel.exception.SystemException {
269                    return getPersistence().countByUuid(uuid);
270            }
271    
272            /**
273            * 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.
274            *
275            * @param uuid the uuid
276            * @param groupId the group ID
277            * @return the matching blogs entry
278            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
279            * @throws SystemException if a system exception occurred
280            */
281            public static com.liferay.portlet.blogs.model.BlogsEntry findByUUID_G(
282                    java.lang.String uuid, long groupId)
283                    throws com.liferay.portal.kernel.exception.SystemException,
284                            com.liferay.portlet.blogs.NoSuchEntryException {
285                    return getPersistence().findByUUID_G(uuid, groupId);
286            }
287    
288            /**
289            * 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.
290            *
291            * @param uuid the uuid
292            * @param groupId the group ID
293            * @return the matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
294            * @throws SystemException if a system exception occurred
295            */
296            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByUUID_G(
297                    java.lang.String uuid, long groupId)
298                    throws com.liferay.portal.kernel.exception.SystemException {
299                    return getPersistence().fetchByUUID_G(uuid, groupId);
300            }
301    
302            /**
303            * 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.
304            *
305            * @param uuid the uuid
306            * @param groupId the group ID
307            * @param retrieveFromCache whether to use the finder cache
308            * @return the matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
309            * @throws SystemException if a system exception occurred
310            */
311            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByUUID_G(
312                    java.lang.String uuid, long groupId, boolean retrieveFromCache)
313                    throws com.liferay.portal.kernel.exception.SystemException {
314                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
315            }
316    
317            /**
318            * Removes the blogs entry where uuid = &#63; and groupId = &#63; from the database.
319            *
320            * @param uuid the uuid
321            * @param groupId the group ID
322            * @return the blogs entry that was removed
323            * @throws SystemException if a system exception occurred
324            */
325            public static com.liferay.portlet.blogs.model.BlogsEntry removeByUUID_G(
326                    java.lang.String uuid, long groupId)
327                    throws com.liferay.portal.kernel.exception.SystemException,
328                            com.liferay.portlet.blogs.NoSuchEntryException {
329                    return getPersistence().removeByUUID_G(uuid, groupId);
330            }
331    
332            /**
333            * Returns the number of blogs entries where uuid = &#63; and groupId = &#63;.
334            *
335            * @param uuid the uuid
336            * @param groupId the group ID
337            * @return the number of matching blogs entries
338            * @throws SystemException if a system exception occurred
339            */
340            public static int countByUUID_G(java.lang.String uuid, long groupId)
341                    throws com.liferay.portal.kernel.exception.SystemException {
342                    return getPersistence().countByUUID_G(uuid, groupId);
343            }
344    
345            /**
346            * Returns all the blogs entries where uuid = &#63; and companyId = &#63;.
347            *
348            * @param uuid the uuid
349            * @param companyId the company ID
350            * @return the matching blogs entries
351            * @throws SystemException if a system exception occurred
352            */
353            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByUuid_C(
354                    java.lang.String uuid, long companyId)
355                    throws com.liferay.portal.kernel.exception.SystemException {
356                    return getPersistence().findByUuid_C(uuid, companyId);
357            }
358    
359            /**
360            * Returns a range of all the blogs entries where uuid = &#63; and companyId = &#63;.
361            *
362            * <p>
363            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
364            * </p>
365            *
366            * @param uuid the uuid
367            * @param companyId the company ID
368            * @param start the lower bound of the range of blogs entries
369            * @param end the upper bound of the range of blogs entries (not inclusive)
370            * @return the range of matching blogs entries
371            * @throws SystemException if a system exception occurred
372            */
373            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByUuid_C(
374                    java.lang.String uuid, long companyId, int start, int end)
375                    throws com.liferay.portal.kernel.exception.SystemException {
376                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
377            }
378    
379            /**
380            * Returns an ordered range of all the blogs entries where uuid = &#63; and companyId = &#63;.
381            *
382            * <p>
383            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
384            * </p>
385            *
386            * @param uuid the uuid
387            * @param companyId the company ID
388            * @param start the lower bound of the range of blogs entries
389            * @param end the upper bound of the range of blogs entries (not inclusive)
390            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
391            * @return the ordered range of matching blogs entries
392            * @throws SystemException if a system exception occurred
393            */
394            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByUuid_C(
395                    java.lang.String uuid, long companyId, int start, int end,
396                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
397                    throws com.liferay.portal.kernel.exception.SystemException {
398                    return getPersistence()
399                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
400            }
401    
402            /**
403            * Returns the first blogs entry in the ordered set where uuid = &#63; and companyId = &#63;.
404            *
405            * @param uuid the uuid
406            * @param companyId the company ID
407            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
408            * @return the first matching blogs entry
409            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
410            * @throws SystemException if a system exception occurred
411            */
412            public static com.liferay.portlet.blogs.model.BlogsEntry findByUuid_C_First(
413                    java.lang.String uuid, long companyId,
414                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
415                    throws com.liferay.portal.kernel.exception.SystemException,
416                            com.liferay.portlet.blogs.NoSuchEntryException {
417                    return getPersistence()
418                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
419            }
420    
421            /**
422            * Returns the first blogs entry in the ordered set where uuid = &#63; and companyId = &#63;.
423            *
424            * @param uuid the uuid
425            * @param companyId the company ID
426            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
427            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
428            * @throws SystemException if a system exception occurred
429            */
430            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByUuid_C_First(
431                    java.lang.String uuid, long companyId,
432                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
433                    throws com.liferay.portal.kernel.exception.SystemException {
434                    return getPersistence()
435                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
436            }
437    
438            /**
439            * Returns the last blogs entry in the ordered set where uuid = &#63; and companyId = &#63;.
440            *
441            * @param uuid the uuid
442            * @param companyId the company ID
443            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
444            * @return the last matching blogs entry
445            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
446            * @throws SystemException if a system exception occurred
447            */
448            public static com.liferay.portlet.blogs.model.BlogsEntry findByUuid_C_Last(
449                    java.lang.String uuid, long companyId,
450                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
451                    throws com.liferay.portal.kernel.exception.SystemException,
452                            com.liferay.portlet.blogs.NoSuchEntryException {
453                    return getPersistence()
454                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
455            }
456    
457            /**
458            * Returns the last blogs entry in the ordered set where uuid = &#63; and companyId = &#63;.
459            *
460            * @param uuid the uuid
461            * @param companyId the company ID
462            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
463            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
464            * @throws SystemException if a system exception occurred
465            */
466            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByUuid_C_Last(
467                    java.lang.String uuid, long companyId,
468                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
469                    throws com.liferay.portal.kernel.exception.SystemException {
470                    return getPersistence()
471                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
472            }
473    
474            /**
475            * Returns the blogs entries before and after the current blogs entry in the ordered set where uuid = &#63; and companyId = &#63;.
476            *
477            * @param entryId the primary key of the current blogs entry
478            * @param uuid the uuid
479            * @param companyId the company ID
480            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
481            * @return the previous, current, and next blogs entry
482            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
483            * @throws SystemException if a system exception occurred
484            */
485            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByUuid_C_PrevAndNext(
486                    long entryId, java.lang.String uuid, long companyId,
487                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
488                    throws com.liferay.portal.kernel.exception.SystemException,
489                            com.liferay.portlet.blogs.NoSuchEntryException {
490                    return getPersistence()
491                                       .findByUuid_C_PrevAndNext(entryId, uuid, companyId,
492                            orderByComparator);
493            }
494    
495            /**
496            * Removes all the blogs entries where uuid = &#63; and companyId = &#63; from the database.
497            *
498            * @param uuid the uuid
499            * @param companyId the company ID
500            * @throws SystemException if a system exception occurred
501            */
502            public static void removeByUuid_C(java.lang.String uuid, long companyId)
503                    throws com.liferay.portal.kernel.exception.SystemException {
504                    getPersistence().removeByUuid_C(uuid, companyId);
505            }
506    
507            /**
508            * Returns the number of blogs entries where uuid = &#63; and companyId = &#63;.
509            *
510            * @param uuid the uuid
511            * @param companyId the company ID
512            * @return the number of matching blogs entries
513            * @throws SystemException if a system exception occurred
514            */
515            public static int countByUuid_C(java.lang.String uuid, long companyId)
516                    throws com.liferay.portal.kernel.exception.SystemException {
517                    return getPersistence().countByUuid_C(uuid, companyId);
518            }
519    
520            /**
521            * Returns all the blogs entries where groupId = &#63;.
522            *
523            * @param groupId the group ID
524            * @return the matching blogs entries
525            * @throws SystemException if a system exception occurred
526            */
527            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByGroupId(
528                    long groupId)
529                    throws com.liferay.portal.kernel.exception.SystemException {
530                    return getPersistence().findByGroupId(groupId);
531            }
532    
533            /**
534            * Returns a range of all the blogs entries where groupId = &#63;.
535            *
536            * <p>
537            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
538            * </p>
539            *
540            * @param groupId the group ID
541            * @param start the lower bound of the range of blogs entries
542            * @param end the upper bound of the range of blogs entries (not inclusive)
543            * @return the range of matching blogs entries
544            * @throws SystemException if a system exception occurred
545            */
546            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByGroupId(
547                    long groupId, int start, int end)
548                    throws com.liferay.portal.kernel.exception.SystemException {
549                    return getPersistence().findByGroupId(groupId, start, end);
550            }
551    
552            /**
553            * Returns an ordered range of all the blogs entries where groupId = &#63;.
554            *
555            * <p>
556            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
557            * </p>
558            *
559            * @param groupId the group ID
560            * @param start the lower bound of the range of blogs entries
561            * @param end the upper bound of the range of blogs entries (not inclusive)
562            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
563            * @return the ordered range of matching blogs entries
564            * @throws SystemException if a system exception occurred
565            */
566            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByGroupId(
567                    long groupId, int start, int end,
568                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
569                    throws com.liferay.portal.kernel.exception.SystemException {
570                    return getPersistence()
571                                       .findByGroupId(groupId, start, end, orderByComparator);
572            }
573    
574            /**
575            * Returns the first blogs entry in the ordered set where groupId = &#63;.
576            *
577            * @param groupId the group ID
578            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
579            * @return the first matching blogs entry
580            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
581            * @throws SystemException if a system exception occurred
582            */
583            public static com.liferay.portlet.blogs.model.BlogsEntry findByGroupId_First(
584                    long groupId,
585                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
586                    throws com.liferay.portal.kernel.exception.SystemException,
587                            com.liferay.portlet.blogs.NoSuchEntryException {
588                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
589            }
590    
591            /**
592            * Returns the first blogs entry in the ordered set where groupId = &#63;.
593            *
594            * @param groupId the group ID
595            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
596            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
597            * @throws SystemException if a system exception occurred
598            */
599            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByGroupId_First(
600                    long groupId,
601                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
602                    throws com.liferay.portal.kernel.exception.SystemException {
603                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
604            }
605    
606            /**
607            * Returns the last blogs entry in the ordered set where groupId = &#63;.
608            *
609            * @param groupId the group ID
610            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
611            * @return the last matching blogs entry
612            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
613            * @throws SystemException if a system exception occurred
614            */
615            public static com.liferay.portlet.blogs.model.BlogsEntry findByGroupId_Last(
616                    long groupId,
617                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
618                    throws com.liferay.portal.kernel.exception.SystemException,
619                            com.liferay.portlet.blogs.NoSuchEntryException {
620                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
621            }
622    
623            /**
624            * Returns the last blogs entry in the ordered set where groupId = &#63;.
625            *
626            * @param groupId the group ID
627            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
628            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
629            * @throws SystemException if a system exception occurred
630            */
631            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByGroupId_Last(
632                    long groupId,
633                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
634                    throws com.liferay.portal.kernel.exception.SystemException {
635                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
636            }
637    
638            /**
639            * Returns the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63;.
640            *
641            * @param entryId the primary key of the current blogs entry
642            * @param groupId the group ID
643            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
644            * @return the previous, current, and next blogs entry
645            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
646            * @throws SystemException if a system exception occurred
647            */
648            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByGroupId_PrevAndNext(
649                    long entryId, long groupId,
650                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
651                    throws com.liferay.portal.kernel.exception.SystemException,
652                            com.liferay.portlet.blogs.NoSuchEntryException {
653                    return getPersistence()
654                                       .findByGroupId_PrevAndNext(entryId, groupId,
655                            orderByComparator);
656            }
657    
658            /**
659            * Returns all the blogs entries that the user has permission to view where groupId = &#63;.
660            *
661            * @param groupId the group ID
662            * @return the matching blogs entries that the user has permission to view
663            * @throws SystemException if a system exception occurred
664            */
665            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByGroupId(
666                    long groupId)
667                    throws com.liferay.portal.kernel.exception.SystemException {
668                    return getPersistence().filterFindByGroupId(groupId);
669            }
670    
671            /**
672            * Returns a range of all the blogs entries that the user has permission to view where groupId = &#63;.
673            *
674            * <p>
675            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
676            * </p>
677            *
678            * @param groupId the group ID
679            * @param start the lower bound of the range of blogs entries
680            * @param end the upper bound of the range of blogs entries (not inclusive)
681            * @return the range of matching blogs entries that the user has permission to view
682            * @throws SystemException if a system exception occurred
683            */
684            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByGroupId(
685                    long groupId, int start, int end)
686                    throws com.liferay.portal.kernel.exception.SystemException {
687                    return getPersistence().filterFindByGroupId(groupId, start, end);
688            }
689    
690            /**
691            * Returns an ordered range of all the blogs entries that the user has permissions to view where groupId = &#63;.
692            *
693            * <p>
694            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
695            * </p>
696            *
697            * @param groupId the group ID
698            * @param start the lower bound of the range of blogs entries
699            * @param end the upper bound of the range of blogs entries (not inclusive)
700            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
701            * @return the ordered range of matching blogs entries that the user has permission to view
702            * @throws SystemException if a system exception occurred
703            */
704            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByGroupId(
705                    long groupId, int start, int end,
706                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
707                    throws com.liferay.portal.kernel.exception.SystemException {
708                    return getPersistence()
709                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
710            }
711    
712            /**
713            * 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;.
714            *
715            * @param entryId the primary key of the current blogs entry
716            * @param groupId the group ID
717            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
718            * @return the previous, current, and next blogs entry
719            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
720            * @throws SystemException if a system exception occurred
721            */
722            public static com.liferay.portlet.blogs.model.BlogsEntry[] filterFindByGroupId_PrevAndNext(
723                    long entryId, long groupId,
724                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
725                    throws com.liferay.portal.kernel.exception.SystemException,
726                            com.liferay.portlet.blogs.NoSuchEntryException {
727                    return getPersistence()
728                                       .filterFindByGroupId_PrevAndNext(entryId, groupId,
729                            orderByComparator);
730            }
731    
732            /**
733            * Removes all the blogs entries where groupId = &#63; from the database.
734            *
735            * @param groupId the group ID
736            * @throws SystemException if a system exception occurred
737            */
738            public static void removeByGroupId(long groupId)
739                    throws com.liferay.portal.kernel.exception.SystemException {
740                    getPersistence().removeByGroupId(groupId);
741            }
742    
743            /**
744            * Returns the number of blogs entries where groupId = &#63;.
745            *
746            * @param groupId the group ID
747            * @return the number of matching blogs entries
748            * @throws SystemException if a system exception occurred
749            */
750            public static int countByGroupId(long groupId)
751                    throws com.liferay.portal.kernel.exception.SystemException {
752                    return getPersistence().countByGroupId(groupId);
753            }
754    
755            /**
756            * Returns the number of blogs entries that the user has permission to view where groupId = &#63;.
757            *
758            * @param groupId the group ID
759            * @return the number of matching blogs entries that the user has permission to view
760            * @throws SystemException if a system exception occurred
761            */
762            public static int filterCountByGroupId(long groupId)
763                    throws com.liferay.portal.kernel.exception.SystemException {
764                    return getPersistence().filterCountByGroupId(groupId);
765            }
766    
767            /**
768            * Returns all the blogs entries where companyId = &#63;.
769            *
770            * @param companyId the company ID
771            * @return the matching blogs entries
772            * @throws SystemException if a system exception occurred
773            */
774            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByCompanyId(
775                    long companyId)
776                    throws com.liferay.portal.kernel.exception.SystemException {
777                    return getPersistence().findByCompanyId(companyId);
778            }
779    
780            /**
781            * Returns a range of all the blogs entries where companyId = &#63;.
782            *
783            * <p>
784            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
785            * </p>
786            *
787            * @param companyId the company ID
788            * @param start the lower bound of the range of blogs entries
789            * @param end the upper bound of the range of blogs entries (not inclusive)
790            * @return the range of matching blogs entries
791            * @throws SystemException if a system exception occurred
792            */
793            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByCompanyId(
794                    long companyId, int start, int end)
795                    throws com.liferay.portal.kernel.exception.SystemException {
796                    return getPersistence().findByCompanyId(companyId, start, end);
797            }
798    
799            /**
800            * Returns an ordered range of all the blogs entries where companyId = &#63;.
801            *
802            * <p>
803            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
804            * </p>
805            *
806            * @param companyId the company ID
807            * @param start the lower bound of the range of blogs entries
808            * @param end the upper bound of the range of blogs entries (not inclusive)
809            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
810            * @return the ordered range of matching blogs entries
811            * @throws SystemException if a system exception occurred
812            */
813            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByCompanyId(
814                    long companyId, int start, int end,
815                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
816                    throws com.liferay.portal.kernel.exception.SystemException {
817                    return getPersistence()
818                                       .findByCompanyId(companyId, start, end, orderByComparator);
819            }
820    
821            /**
822            * Returns the first blogs entry in the ordered set where companyId = &#63;.
823            *
824            * @param companyId the company ID
825            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
826            * @return the first matching blogs entry
827            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
828            * @throws SystemException if a system exception occurred
829            */
830            public static com.liferay.portlet.blogs.model.BlogsEntry findByCompanyId_First(
831                    long companyId,
832                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
833                    throws com.liferay.portal.kernel.exception.SystemException,
834                            com.liferay.portlet.blogs.NoSuchEntryException {
835                    return getPersistence()
836                                       .findByCompanyId_First(companyId, orderByComparator);
837            }
838    
839            /**
840            * Returns the first blogs entry in the ordered set where companyId = &#63;.
841            *
842            * @param companyId the company ID
843            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
844            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
845            * @throws SystemException if a system exception occurred
846            */
847            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByCompanyId_First(
848                    long companyId,
849                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
850                    throws com.liferay.portal.kernel.exception.SystemException {
851                    return getPersistence()
852                                       .fetchByCompanyId_First(companyId, orderByComparator);
853            }
854    
855            /**
856            * Returns the last blogs entry in the ordered set where companyId = &#63;.
857            *
858            * @param companyId the company ID
859            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
860            * @return the last matching blogs entry
861            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
862            * @throws SystemException if a system exception occurred
863            */
864            public static com.liferay.portlet.blogs.model.BlogsEntry findByCompanyId_Last(
865                    long companyId,
866                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
867                    throws com.liferay.portal.kernel.exception.SystemException,
868                            com.liferay.portlet.blogs.NoSuchEntryException {
869                    return getPersistence()
870                                       .findByCompanyId_Last(companyId, orderByComparator);
871            }
872    
873            /**
874            * Returns the last blogs entry in the ordered set where companyId = &#63;.
875            *
876            * @param companyId the company ID
877            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
878            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
879            * @throws SystemException if a system exception occurred
880            */
881            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByCompanyId_Last(
882                    long companyId,
883                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
884                    throws com.liferay.portal.kernel.exception.SystemException {
885                    return getPersistence()
886                                       .fetchByCompanyId_Last(companyId, orderByComparator);
887            }
888    
889            /**
890            * Returns the blogs entries before and after the current blogs entry in the ordered set where companyId = &#63;.
891            *
892            * @param entryId the primary key of the current blogs entry
893            * @param companyId the company ID
894            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
895            * @return the previous, current, and next blogs entry
896            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
897            * @throws SystemException if a system exception occurred
898            */
899            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByCompanyId_PrevAndNext(
900                    long entryId, long companyId,
901                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
902                    throws com.liferay.portal.kernel.exception.SystemException,
903                            com.liferay.portlet.blogs.NoSuchEntryException {
904                    return getPersistence()
905                                       .findByCompanyId_PrevAndNext(entryId, companyId,
906                            orderByComparator);
907            }
908    
909            /**
910            * Removes all the blogs entries where companyId = &#63; from the database.
911            *
912            * @param companyId the company ID
913            * @throws SystemException if a system exception occurred
914            */
915            public static void removeByCompanyId(long companyId)
916                    throws com.liferay.portal.kernel.exception.SystemException {
917                    getPersistence().removeByCompanyId(companyId);
918            }
919    
920            /**
921            * Returns the number of blogs entries where companyId = &#63;.
922            *
923            * @param companyId the company ID
924            * @return the number of matching blogs entries
925            * @throws SystemException if a system exception occurred
926            */
927            public static int countByCompanyId(long companyId)
928                    throws com.liferay.portal.kernel.exception.SystemException {
929                    return getPersistence().countByCompanyId(companyId);
930            }
931    
932            /**
933            * Returns all the blogs entries where companyId = &#63; and userId = &#63;.
934            *
935            * @param companyId the company ID
936            * @param userId the user ID
937            * @return the matching blogs entries
938            * @throws SystemException if a system exception occurred
939            */
940            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_U(
941                    long companyId, long userId)
942                    throws com.liferay.portal.kernel.exception.SystemException {
943                    return getPersistence().findByC_U(companyId, userId);
944            }
945    
946            /**
947            * Returns a range of all the blogs entries where companyId = &#63; and userId = &#63;.
948            *
949            * <p>
950            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
951            * </p>
952            *
953            * @param companyId the company ID
954            * @param userId the user ID
955            * @param start the lower bound of the range of blogs entries
956            * @param end the upper bound of the range of blogs entries (not inclusive)
957            * @return the range of matching blogs entries
958            * @throws SystemException if a system exception occurred
959            */
960            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_U(
961                    long companyId, long userId, int start, int end)
962                    throws com.liferay.portal.kernel.exception.SystemException {
963                    return getPersistence().findByC_U(companyId, userId, start, end);
964            }
965    
966            /**
967            * Returns an ordered range of all the blogs entries where companyId = &#63; and userId = &#63;.
968            *
969            * <p>
970            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
971            * </p>
972            *
973            * @param companyId the company ID
974            * @param userId the user ID
975            * @param start the lower bound of the range of blogs entries
976            * @param end the upper bound of the range of blogs entries (not inclusive)
977            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
978            * @return the ordered range of matching blogs entries
979            * @throws SystemException if a system exception occurred
980            */
981            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_U(
982                    long companyId, long userId, int start, int end,
983                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
984                    throws com.liferay.portal.kernel.exception.SystemException {
985                    return getPersistence()
986                                       .findByC_U(companyId, userId, start, end, orderByComparator);
987            }
988    
989            /**
990            * Returns the first blogs entry in the ordered set where companyId = &#63; and userId = &#63;.
991            *
992            * @param companyId the company ID
993            * @param userId the user ID
994            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
995            * @return the first matching blogs entry
996            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
997            * @throws SystemException if a system exception occurred
998            */
999            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_U_First(
1000                    long companyId, long userId,
1001                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1002                    throws com.liferay.portal.kernel.exception.SystemException,
1003                            com.liferay.portlet.blogs.NoSuchEntryException {
1004                    return getPersistence()
1005                                       .findByC_U_First(companyId, userId, orderByComparator);
1006            }
1007    
1008            /**
1009            * Returns the first blogs entry in the ordered set where companyId = &#63; and userId = &#63;.
1010            *
1011            * @param companyId the company ID
1012            * @param userId the user ID
1013            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1014            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
1015            * @throws SystemException if a system exception occurred
1016            */
1017            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByC_U_First(
1018                    long companyId, long userId,
1019                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1020                    throws com.liferay.portal.kernel.exception.SystemException {
1021                    return getPersistence()
1022                                       .fetchByC_U_First(companyId, userId, orderByComparator);
1023            }
1024    
1025            /**
1026            * Returns the last blogs entry in the ordered set where companyId = &#63; and userId = &#63;.
1027            *
1028            * @param companyId the company ID
1029            * @param userId the user ID
1030            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1031            * @return the last matching blogs entry
1032            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1033            * @throws SystemException if a system exception occurred
1034            */
1035            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_U_Last(
1036                    long companyId, long userId,
1037                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1038                    throws com.liferay.portal.kernel.exception.SystemException,
1039                            com.liferay.portlet.blogs.NoSuchEntryException {
1040                    return getPersistence()
1041                                       .findByC_U_Last(companyId, userId, orderByComparator);
1042            }
1043    
1044            /**
1045            * Returns the last blogs entry in the ordered set where companyId = &#63; and userId = &#63;.
1046            *
1047            * @param companyId the company ID
1048            * @param userId the user ID
1049            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1050            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
1051            * @throws SystemException if a system exception occurred
1052            */
1053            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByC_U_Last(
1054                    long companyId, long userId,
1055                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1056                    throws com.liferay.portal.kernel.exception.SystemException {
1057                    return getPersistence()
1058                                       .fetchByC_U_Last(companyId, userId, orderByComparator);
1059            }
1060    
1061            /**
1062            * Returns the blogs entries before and after the current blogs entry in the ordered set where companyId = &#63; and userId = &#63;.
1063            *
1064            * @param entryId the primary key of the current blogs entry
1065            * @param companyId the company ID
1066            * @param userId the user ID
1067            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1068            * @return the previous, current, and next blogs entry
1069            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
1070            * @throws SystemException if a system exception occurred
1071            */
1072            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByC_U_PrevAndNext(
1073                    long entryId, long companyId, long userId,
1074                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1075                    throws com.liferay.portal.kernel.exception.SystemException,
1076                            com.liferay.portlet.blogs.NoSuchEntryException {
1077                    return getPersistence()
1078                                       .findByC_U_PrevAndNext(entryId, companyId, userId,
1079                            orderByComparator);
1080            }
1081    
1082            /**
1083            * Removes all the blogs entries where companyId = &#63; and userId = &#63; from the database.
1084            *
1085            * @param companyId the company ID
1086            * @param userId the user ID
1087            * @throws SystemException if a system exception occurred
1088            */
1089            public static void removeByC_U(long companyId, long userId)
1090                    throws com.liferay.portal.kernel.exception.SystemException {
1091                    getPersistence().removeByC_U(companyId, userId);
1092            }
1093    
1094            /**
1095            * Returns the number of blogs entries where companyId = &#63; and userId = &#63;.
1096            *
1097            * @param companyId the company ID
1098            * @param userId the user ID
1099            * @return the number of matching blogs entries
1100            * @throws SystemException if a system exception occurred
1101            */
1102            public static int countByC_U(long companyId, long userId)
1103                    throws com.liferay.portal.kernel.exception.SystemException {
1104                    return getPersistence().countByC_U(companyId, userId);
1105            }
1106    
1107            /**
1108            * Returns all the blogs entries where companyId = &#63; and displayDate &lt; &#63;.
1109            *
1110            * @param companyId the company ID
1111            * @param displayDate the display date
1112            * @return the matching blogs entries
1113            * @throws SystemException if a system exception occurred
1114            */
1115            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_LtD(
1116                    long companyId, java.util.Date displayDate)
1117                    throws com.liferay.portal.kernel.exception.SystemException {
1118                    return getPersistence().findByC_LtD(companyId, displayDate);
1119            }
1120    
1121            /**
1122            * Returns a range of all the blogs entries where companyId = &#63; and displayDate &lt; &#63;.
1123            *
1124            * <p>
1125            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1126            * </p>
1127            *
1128            * @param companyId the company ID
1129            * @param displayDate the display date
1130            * @param start the lower bound of the range of blogs entries
1131            * @param end the upper bound of the range of blogs entries (not inclusive)
1132            * @return the range of matching blogs entries
1133            * @throws SystemException if a system exception occurred
1134            */
1135            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_LtD(
1136                    long companyId, java.util.Date displayDate, int start, int end)
1137                    throws com.liferay.portal.kernel.exception.SystemException {
1138                    return getPersistence().findByC_LtD(companyId, displayDate, start, end);
1139            }
1140    
1141            /**
1142            * Returns an ordered range of all the blogs entries where companyId = &#63; and displayDate &lt; &#63;.
1143            *
1144            * <p>
1145            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1146            * </p>
1147            *
1148            * @param companyId the company ID
1149            * @param displayDate the display date
1150            * @param start the lower bound of the range of blogs entries
1151            * @param end the upper bound of the range of blogs entries (not inclusive)
1152            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1153            * @return the ordered range of matching blogs entries
1154            * @throws SystemException if a system exception occurred
1155            */
1156            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_LtD(
1157                    long companyId, java.util.Date displayDate, int start, int end,
1158                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1159                    throws com.liferay.portal.kernel.exception.SystemException {
1160                    return getPersistence()
1161                                       .findByC_LtD(companyId, displayDate, start, end,
1162                            orderByComparator);
1163            }
1164    
1165            /**
1166            * Returns the first blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63;.
1167            *
1168            * @param companyId the company ID
1169            * @param displayDate the display date
1170            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1171            * @return the first matching blogs entry
1172            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1173            * @throws SystemException if a system exception occurred
1174            */
1175            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_LtD_First(
1176                    long companyId, java.util.Date displayDate,
1177                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1178                    throws com.liferay.portal.kernel.exception.SystemException,
1179                            com.liferay.portlet.blogs.NoSuchEntryException {
1180                    return getPersistence()
1181                                       .findByC_LtD_First(companyId, displayDate, orderByComparator);
1182            }
1183    
1184            /**
1185            * Returns the first blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63;.
1186            *
1187            * @param companyId the company ID
1188            * @param displayDate the display date
1189            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1190            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
1191            * @throws SystemException if a system exception occurred
1192            */
1193            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByC_LtD_First(
1194                    long companyId, java.util.Date displayDate,
1195                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1196                    throws com.liferay.portal.kernel.exception.SystemException {
1197                    return getPersistence()
1198                                       .fetchByC_LtD_First(companyId, displayDate, orderByComparator);
1199            }
1200    
1201            /**
1202            * Returns the last blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63;.
1203            *
1204            * @param companyId the company ID
1205            * @param displayDate the display date
1206            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1207            * @return the last matching blogs entry
1208            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1209            * @throws SystemException if a system exception occurred
1210            */
1211            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_LtD_Last(
1212                    long companyId, java.util.Date displayDate,
1213                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1214                    throws com.liferay.portal.kernel.exception.SystemException,
1215                            com.liferay.portlet.blogs.NoSuchEntryException {
1216                    return getPersistence()
1217                                       .findByC_LtD_Last(companyId, displayDate, orderByComparator);
1218            }
1219    
1220            /**
1221            * Returns the last blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63;.
1222            *
1223            * @param companyId the company ID
1224            * @param displayDate the display date
1225            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1226            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
1227            * @throws SystemException if a system exception occurred
1228            */
1229            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByC_LtD_Last(
1230                    long companyId, java.util.Date displayDate,
1231                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1232                    throws com.liferay.portal.kernel.exception.SystemException {
1233                    return getPersistence()
1234                                       .fetchByC_LtD_Last(companyId, displayDate, orderByComparator);
1235            }
1236    
1237            /**
1238            * Returns the blogs entries before and after the current blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63;.
1239            *
1240            * @param entryId the primary key of the current blogs entry
1241            * @param companyId the company ID
1242            * @param displayDate the display date
1243            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1244            * @return the previous, current, and next blogs entry
1245            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
1246            * @throws SystemException if a system exception occurred
1247            */
1248            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByC_LtD_PrevAndNext(
1249                    long entryId, long companyId, java.util.Date displayDate,
1250                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1251                    throws com.liferay.portal.kernel.exception.SystemException,
1252                            com.liferay.portlet.blogs.NoSuchEntryException {
1253                    return getPersistence()
1254                                       .findByC_LtD_PrevAndNext(entryId, companyId, displayDate,
1255                            orderByComparator);
1256            }
1257    
1258            /**
1259            * Removes all the blogs entries where companyId = &#63; and displayDate &lt; &#63; from the database.
1260            *
1261            * @param companyId the company ID
1262            * @param displayDate the display date
1263            * @throws SystemException if a system exception occurred
1264            */
1265            public static void removeByC_LtD(long companyId, java.util.Date displayDate)
1266                    throws com.liferay.portal.kernel.exception.SystemException {
1267                    getPersistence().removeByC_LtD(companyId, displayDate);
1268            }
1269    
1270            /**
1271            * Returns the number of blogs entries where companyId = &#63; and displayDate &lt; &#63;.
1272            *
1273            * @param companyId the company ID
1274            * @param displayDate the display date
1275            * @return the number of matching blogs entries
1276            * @throws SystemException if a system exception occurred
1277            */
1278            public static int countByC_LtD(long companyId, java.util.Date displayDate)
1279                    throws com.liferay.portal.kernel.exception.SystemException {
1280                    return getPersistence().countByC_LtD(companyId, displayDate);
1281            }
1282    
1283            /**
1284            * Returns all the blogs entries where companyId = &#63; and status &ne; &#63;.
1285            *
1286            * @param companyId the company ID
1287            * @param status the status
1288            * @return the matching blogs entries
1289            * @throws SystemException if a system exception occurred
1290            */
1291            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_NotS(
1292                    long companyId, int status)
1293                    throws com.liferay.portal.kernel.exception.SystemException {
1294                    return getPersistence().findByC_NotS(companyId, status);
1295            }
1296    
1297            /**
1298            * Returns a range of all the blogs entries where companyId = &#63; and status &ne; &#63;.
1299            *
1300            * <p>
1301            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1302            * </p>
1303            *
1304            * @param companyId the company ID
1305            * @param status the status
1306            * @param start the lower bound of the range of blogs entries
1307            * @param end the upper bound of the range of blogs entries (not inclusive)
1308            * @return the range of matching blogs entries
1309            * @throws SystemException if a system exception occurred
1310            */
1311            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_NotS(
1312                    long companyId, int status, int start, int end)
1313                    throws com.liferay.portal.kernel.exception.SystemException {
1314                    return getPersistence().findByC_NotS(companyId, status, start, end);
1315            }
1316    
1317            /**
1318            * Returns an ordered range of all the blogs entries where companyId = &#63; and status &ne; &#63;.
1319            *
1320            * <p>
1321            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1322            * </p>
1323            *
1324            * @param companyId the company ID
1325            * @param status the status
1326            * @param start the lower bound of the range of blogs entries
1327            * @param end the upper bound of the range of blogs entries (not inclusive)
1328            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1329            * @return the ordered range of matching blogs entries
1330            * @throws SystemException if a system exception occurred
1331            */
1332            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_NotS(
1333                    long companyId, int status, int start, int end,
1334                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1335                    throws com.liferay.portal.kernel.exception.SystemException {
1336                    return getPersistence()
1337                                       .findByC_NotS(companyId, status, start, end,
1338                            orderByComparator);
1339            }
1340    
1341            /**
1342            * Returns the first blogs entry in the ordered set where companyId = &#63; and status &ne; &#63;.
1343            *
1344            * @param companyId the company ID
1345            * @param status the status
1346            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1347            * @return the first matching blogs entry
1348            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1349            * @throws SystemException if a system exception occurred
1350            */
1351            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_NotS_First(
1352                    long companyId, int status,
1353                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1354                    throws com.liferay.portal.kernel.exception.SystemException,
1355                            com.liferay.portlet.blogs.NoSuchEntryException {
1356                    return getPersistence()
1357                                       .findByC_NotS_First(companyId, status, orderByComparator);
1358            }
1359    
1360            /**
1361            * Returns the first blogs entry in the ordered set where companyId = &#63; and status &ne; &#63;.
1362            *
1363            * @param companyId the company ID
1364            * @param status the status
1365            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1366            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
1367            * @throws SystemException if a system exception occurred
1368            */
1369            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByC_NotS_First(
1370                    long companyId, int status,
1371                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1372                    throws com.liferay.portal.kernel.exception.SystemException {
1373                    return getPersistence()
1374                                       .fetchByC_NotS_First(companyId, status, orderByComparator);
1375            }
1376    
1377            /**
1378            * Returns the last blogs entry in the ordered set where companyId = &#63; and status &ne; &#63;.
1379            *
1380            * @param companyId the company ID
1381            * @param status the status
1382            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1383            * @return the last matching blogs entry
1384            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1385            * @throws SystemException if a system exception occurred
1386            */
1387            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_NotS_Last(
1388                    long companyId, int status,
1389                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1390                    throws com.liferay.portal.kernel.exception.SystemException,
1391                            com.liferay.portlet.blogs.NoSuchEntryException {
1392                    return getPersistence()
1393                                       .findByC_NotS_Last(companyId, status, orderByComparator);
1394            }
1395    
1396            /**
1397            * Returns the last blogs entry in the ordered set where companyId = &#63; and status &ne; &#63;.
1398            *
1399            * @param companyId the company ID
1400            * @param status the status
1401            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1402            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
1403            * @throws SystemException if a system exception occurred
1404            */
1405            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByC_NotS_Last(
1406                    long companyId, int status,
1407                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1408                    throws com.liferay.portal.kernel.exception.SystemException {
1409                    return getPersistence()
1410                                       .fetchByC_NotS_Last(companyId, status, orderByComparator);
1411            }
1412    
1413            /**
1414            * Returns the blogs entries before and after the current blogs entry in the ordered set where companyId = &#63; and status &ne; &#63;.
1415            *
1416            * @param entryId the primary key of the current blogs entry
1417            * @param companyId the company ID
1418            * @param status the status
1419            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1420            * @return the previous, current, and next blogs entry
1421            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
1422            * @throws SystemException if a system exception occurred
1423            */
1424            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByC_NotS_PrevAndNext(
1425                    long entryId, long companyId, int status,
1426                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1427                    throws com.liferay.portal.kernel.exception.SystemException,
1428                            com.liferay.portlet.blogs.NoSuchEntryException {
1429                    return getPersistence()
1430                                       .findByC_NotS_PrevAndNext(entryId, companyId, status,
1431                            orderByComparator);
1432            }
1433    
1434            /**
1435            * Removes all the blogs entries where companyId = &#63; and status &ne; &#63; from the database.
1436            *
1437            * @param companyId the company ID
1438            * @param status the status
1439            * @throws SystemException if a system exception occurred
1440            */
1441            public static void removeByC_NotS(long companyId, int status)
1442                    throws com.liferay.portal.kernel.exception.SystemException {
1443                    getPersistence().removeByC_NotS(companyId, status);
1444            }
1445    
1446            /**
1447            * Returns the number of blogs entries where companyId = &#63; and status &ne; &#63;.
1448            *
1449            * @param companyId the company ID
1450            * @param status the status
1451            * @return the number of matching blogs entries
1452            * @throws SystemException if a system exception occurred
1453            */
1454            public static int countByC_NotS(long companyId, int status)
1455                    throws com.liferay.portal.kernel.exception.SystemException {
1456                    return getPersistence().countByC_NotS(companyId, status);
1457            }
1458    
1459            /**
1460            * Returns all the blogs entries where companyId = &#63; and status = &#63;.
1461            *
1462            * @param companyId the company ID
1463            * @param status the status
1464            * @return the matching blogs entries
1465            * @throws SystemException if a system exception occurred
1466            */
1467            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_S(
1468                    long companyId, int status)
1469                    throws com.liferay.portal.kernel.exception.SystemException {
1470                    return getPersistence().findByC_S(companyId, status);
1471            }
1472    
1473            /**
1474            * Returns a range of all the blogs entries where companyId = &#63; and status = &#63;.
1475            *
1476            * <p>
1477            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1478            * </p>
1479            *
1480            * @param companyId the company ID
1481            * @param status the status
1482            * @param start the lower bound of the range of blogs entries
1483            * @param end the upper bound of the range of blogs entries (not inclusive)
1484            * @return the range of matching blogs entries
1485            * @throws SystemException if a system exception occurred
1486            */
1487            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_S(
1488                    long companyId, int status, int start, int end)
1489                    throws com.liferay.portal.kernel.exception.SystemException {
1490                    return getPersistence().findByC_S(companyId, status, start, end);
1491            }
1492    
1493            /**
1494            * Returns an ordered range of all the blogs entries where companyId = &#63; and status = &#63;.
1495            *
1496            * <p>
1497            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1498            * </p>
1499            *
1500            * @param companyId the company ID
1501            * @param status the status
1502            * @param start the lower bound of the range of blogs entries
1503            * @param end the upper bound of the range of blogs entries (not inclusive)
1504            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1505            * @return the ordered range of matching blogs entries
1506            * @throws SystemException if a system exception occurred
1507            */
1508            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_S(
1509                    long companyId, int status, int start, int end,
1510                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1511                    throws com.liferay.portal.kernel.exception.SystemException {
1512                    return getPersistence()
1513                                       .findByC_S(companyId, status, start, end, orderByComparator);
1514            }
1515    
1516            /**
1517            * Returns the first blogs entry in the ordered set where companyId = &#63; and status = &#63;.
1518            *
1519            * @param companyId the company ID
1520            * @param status the status
1521            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1522            * @return the first matching blogs entry
1523            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1524            * @throws SystemException if a system exception occurred
1525            */
1526            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_S_First(
1527                    long companyId, int status,
1528                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1529                    throws com.liferay.portal.kernel.exception.SystemException,
1530                            com.liferay.portlet.blogs.NoSuchEntryException {
1531                    return getPersistence()
1532                                       .findByC_S_First(companyId, status, orderByComparator);
1533            }
1534    
1535            /**
1536            * Returns the first blogs entry in the ordered set where companyId = &#63; and status = &#63;.
1537            *
1538            * @param companyId the company ID
1539            * @param status the status
1540            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1541            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
1542            * @throws SystemException if a system exception occurred
1543            */
1544            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByC_S_First(
1545                    long companyId, int status,
1546                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1547                    throws com.liferay.portal.kernel.exception.SystemException {
1548                    return getPersistence()
1549                                       .fetchByC_S_First(companyId, status, orderByComparator);
1550            }
1551    
1552            /**
1553            * Returns the last blogs entry in the ordered set where companyId = &#63; and status = &#63;.
1554            *
1555            * @param companyId the company ID
1556            * @param status the status
1557            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1558            * @return the last matching blogs entry
1559            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1560            * @throws SystemException if a system exception occurred
1561            */
1562            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_S_Last(
1563                    long companyId, int status,
1564                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1565                    throws com.liferay.portal.kernel.exception.SystemException,
1566                            com.liferay.portlet.blogs.NoSuchEntryException {
1567                    return getPersistence()
1568                                       .findByC_S_Last(companyId, status, orderByComparator);
1569            }
1570    
1571            /**
1572            * Returns the last blogs entry in the ordered set where companyId = &#63; and status = &#63;.
1573            *
1574            * @param companyId the company ID
1575            * @param status the status
1576            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1577            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
1578            * @throws SystemException if a system exception occurred
1579            */
1580            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByC_S_Last(
1581                    long companyId, int status,
1582                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1583                    throws com.liferay.portal.kernel.exception.SystemException {
1584                    return getPersistence()
1585                                       .fetchByC_S_Last(companyId, status, orderByComparator);
1586            }
1587    
1588            /**
1589            * Returns the blogs entries before and after the current blogs entry in the ordered set where companyId = &#63; and status = &#63;.
1590            *
1591            * @param entryId the primary key of the current blogs entry
1592            * @param companyId the company ID
1593            * @param status the status
1594            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1595            * @return the previous, current, and next blogs entry
1596            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
1597            * @throws SystemException if a system exception occurred
1598            */
1599            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByC_S_PrevAndNext(
1600                    long entryId, long companyId, int status,
1601                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1602                    throws com.liferay.portal.kernel.exception.SystemException,
1603                            com.liferay.portlet.blogs.NoSuchEntryException {
1604                    return getPersistence()
1605                                       .findByC_S_PrevAndNext(entryId, companyId, status,
1606                            orderByComparator);
1607            }
1608    
1609            /**
1610            * Removes all the blogs entries where companyId = &#63; and status = &#63; from the database.
1611            *
1612            * @param companyId the company ID
1613            * @param status the status
1614            * @throws SystemException if a system exception occurred
1615            */
1616            public static void removeByC_S(long companyId, int status)
1617                    throws com.liferay.portal.kernel.exception.SystemException {
1618                    getPersistence().removeByC_S(companyId, status);
1619            }
1620    
1621            /**
1622            * Returns the number of blogs entries where companyId = &#63; and status = &#63;.
1623            *
1624            * @param companyId the company ID
1625            * @param status the status
1626            * @return the number of matching blogs entries
1627            * @throws SystemException if a system exception occurred
1628            */
1629            public static int countByC_S(long companyId, int status)
1630                    throws com.liferay.portal.kernel.exception.SystemException {
1631                    return getPersistence().countByC_S(companyId, status);
1632            }
1633    
1634            /**
1635            * 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.
1636            *
1637            * @param groupId the group ID
1638            * @param urlTitle the url title
1639            * @return the matching blogs entry
1640            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1641            * @throws SystemException if a system exception occurred
1642            */
1643            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_UT(
1644                    long groupId, java.lang.String urlTitle)
1645                    throws com.liferay.portal.kernel.exception.SystemException,
1646                            com.liferay.portlet.blogs.NoSuchEntryException {
1647                    return getPersistence().findByG_UT(groupId, urlTitle);
1648            }
1649    
1650            /**
1651            * 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.
1652            *
1653            * @param groupId the group ID
1654            * @param urlTitle the url title
1655            * @return the matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
1656            * @throws SystemException if a system exception occurred
1657            */
1658            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_UT(
1659                    long groupId, java.lang.String urlTitle)
1660                    throws com.liferay.portal.kernel.exception.SystemException {
1661                    return getPersistence().fetchByG_UT(groupId, urlTitle);
1662            }
1663    
1664            /**
1665            * 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.
1666            *
1667            * @param groupId the group ID
1668            * @param urlTitle the url title
1669            * @param retrieveFromCache whether to use the finder cache
1670            * @return the matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
1671            * @throws SystemException if a system exception occurred
1672            */
1673            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_UT(
1674                    long groupId, java.lang.String urlTitle, boolean retrieveFromCache)
1675                    throws com.liferay.portal.kernel.exception.SystemException {
1676                    return getPersistence().fetchByG_UT(groupId, urlTitle, retrieveFromCache);
1677            }
1678    
1679            /**
1680            * Removes the blogs entry where groupId = &#63; and urlTitle = &#63; from the database.
1681            *
1682            * @param groupId the group ID
1683            * @param urlTitle the url title
1684            * @return the blogs entry that was removed
1685            * @throws SystemException if a system exception occurred
1686            */
1687            public static com.liferay.portlet.blogs.model.BlogsEntry removeByG_UT(
1688                    long groupId, java.lang.String urlTitle)
1689                    throws com.liferay.portal.kernel.exception.SystemException,
1690                            com.liferay.portlet.blogs.NoSuchEntryException {
1691                    return getPersistence().removeByG_UT(groupId, urlTitle);
1692            }
1693    
1694            /**
1695            * Returns the number of blogs entries where groupId = &#63; and urlTitle = &#63;.
1696            *
1697            * @param groupId the group ID
1698            * @param urlTitle the url title
1699            * @return the number of matching blogs entries
1700            * @throws SystemException if a system exception occurred
1701            */
1702            public static int countByG_UT(long groupId, java.lang.String urlTitle)
1703                    throws com.liferay.portal.kernel.exception.SystemException {
1704                    return getPersistence().countByG_UT(groupId, urlTitle);
1705            }
1706    
1707            /**
1708            * Returns all the blogs entries where groupId = &#63; and displayDate &lt; &#63;.
1709            *
1710            * @param groupId the group ID
1711            * @param displayDate the display date
1712            * @return the matching blogs entries
1713            * @throws SystemException if a system exception occurred
1714            */
1715            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_LtD(
1716                    long groupId, java.util.Date displayDate)
1717                    throws com.liferay.portal.kernel.exception.SystemException {
1718                    return getPersistence().findByG_LtD(groupId, displayDate);
1719            }
1720    
1721            /**
1722            * Returns a range of all the blogs entries where groupId = &#63; and displayDate &lt; &#63;.
1723            *
1724            * <p>
1725            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1726            * </p>
1727            *
1728            * @param groupId the group ID
1729            * @param displayDate the display date
1730            * @param start the lower bound of the range of blogs entries
1731            * @param end the upper bound of the range of blogs entries (not inclusive)
1732            * @return the range of matching blogs entries
1733            * @throws SystemException if a system exception occurred
1734            */
1735            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_LtD(
1736                    long groupId, java.util.Date displayDate, int start, int end)
1737                    throws com.liferay.portal.kernel.exception.SystemException {
1738                    return getPersistence().findByG_LtD(groupId, displayDate, start, end);
1739            }
1740    
1741            /**
1742            * Returns an ordered range of all the blogs entries where groupId = &#63; and displayDate &lt; &#63;.
1743            *
1744            * <p>
1745            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1746            * </p>
1747            *
1748            * @param groupId the group ID
1749            * @param displayDate the display date
1750            * @param start the lower bound of the range of blogs entries
1751            * @param end the upper bound of the range of blogs entries (not inclusive)
1752            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1753            * @return the ordered range of matching blogs entries
1754            * @throws SystemException if a system exception occurred
1755            */
1756            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_LtD(
1757                    long groupId, java.util.Date displayDate, int start, int end,
1758                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1759                    throws com.liferay.portal.kernel.exception.SystemException {
1760                    return getPersistence()
1761                                       .findByG_LtD(groupId, displayDate, start, end,
1762                            orderByComparator);
1763            }
1764    
1765            /**
1766            * Returns the first blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63;.
1767            *
1768            * @param groupId the group ID
1769            * @param displayDate the display date
1770            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1771            * @return the first matching blogs entry
1772            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1773            * @throws SystemException if a system exception occurred
1774            */
1775            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_LtD_First(
1776                    long groupId, java.util.Date displayDate,
1777                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1778                    throws com.liferay.portal.kernel.exception.SystemException,
1779                            com.liferay.portlet.blogs.NoSuchEntryException {
1780                    return getPersistence()
1781                                       .findByG_LtD_First(groupId, displayDate, orderByComparator);
1782            }
1783    
1784            /**
1785            * Returns the first blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63;.
1786            *
1787            * @param groupId the group ID
1788            * @param displayDate the display date
1789            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1790            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
1791            * @throws SystemException if a system exception occurred
1792            */
1793            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_LtD_First(
1794                    long groupId, java.util.Date displayDate,
1795                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1796                    throws com.liferay.portal.kernel.exception.SystemException {
1797                    return getPersistence()
1798                                       .fetchByG_LtD_First(groupId, displayDate, orderByComparator);
1799            }
1800    
1801            /**
1802            * Returns the last blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63;.
1803            *
1804            * @param groupId the group ID
1805            * @param displayDate the display date
1806            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1807            * @return the last matching blogs entry
1808            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1809            * @throws SystemException if a system exception occurred
1810            */
1811            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_LtD_Last(
1812                    long groupId, java.util.Date displayDate,
1813                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1814                    throws com.liferay.portal.kernel.exception.SystemException,
1815                            com.liferay.portlet.blogs.NoSuchEntryException {
1816                    return getPersistence()
1817                                       .findByG_LtD_Last(groupId, displayDate, orderByComparator);
1818            }
1819    
1820            /**
1821            * Returns the last blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63;.
1822            *
1823            * @param groupId the group ID
1824            * @param displayDate the display date
1825            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1826            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
1827            * @throws SystemException if a system exception occurred
1828            */
1829            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_LtD_Last(
1830                    long groupId, java.util.Date displayDate,
1831                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1832                    throws com.liferay.portal.kernel.exception.SystemException {
1833                    return getPersistence()
1834                                       .fetchByG_LtD_Last(groupId, displayDate, orderByComparator);
1835            }
1836    
1837            /**
1838            * Returns the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63;.
1839            *
1840            * @param entryId the primary key of the current blogs entry
1841            * @param groupId the group ID
1842            * @param displayDate the display date
1843            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1844            * @return the previous, current, and next blogs entry
1845            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
1846            * @throws SystemException if a system exception occurred
1847            */
1848            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByG_LtD_PrevAndNext(
1849                    long entryId, long groupId, java.util.Date displayDate,
1850                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1851                    throws com.liferay.portal.kernel.exception.SystemException,
1852                            com.liferay.portlet.blogs.NoSuchEntryException {
1853                    return getPersistence()
1854                                       .findByG_LtD_PrevAndNext(entryId, groupId, displayDate,
1855                            orderByComparator);
1856            }
1857    
1858            /**
1859            * Returns all the blogs entries that the user has permission to view where groupId = &#63; and displayDate &lt; &#63;.
1860            *
1861            * @param groupId the group ID
1862            * @param displayDate the display date
1863            * @return the matching blogs entries that the user has permission to view
1864            * @throws SystemException if a system exception occurred
1865            */
1866            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_LtD(
1867                    long groupId, java.util.Date displayDate)
1868                    throws com.liferay.portal.kernel.exception.SystemException {
1869                    return getPersistence().filterFindByG_LtD(groupId, displayDate);
1870            }
1871    
1872            /**
1873            * Returns a range of all the blogs entries that the user has permission to view where groupId = &#63; and displayDate &lt; &#63;.
1874            *
1875            * <p>
1876            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1877            * </p>
1878            *
1879            * @param groupId the group ID
1880            * @param displayDate the display date
1881            * @param start the lower bound of the range of blogs entries
1882            * @param end the upper bound of the range of blogs entries (not inclusive)
1883            * @return the range of matching blogs entries that the user has permission to view
1884            * @throws SystemException if a system exception occurred
1885            */
1886            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_LtD(
1887                    long groupId, java.util.Date displayDate, int start, int end)
1888                    throws com.liferay.portal.kernel.exception.SystemException {
1889                    return getPersistence()
1890                                       .filterFindByG_LtD(groupId, displayDate, start, end);
1891            }
1892    
1893            /**
1894            * Returns an ordered range of all the blogs entries that the user has permissions to view where groupId = &#63; and displayDate &lt; &#63;.
1895            *
1896            * <p>
1897            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1898            * </p>
1899            *
1900            * @param groupId the group ID
1901            * @param displayDate the display date
1902            * @param start the lower bound of the range of blogs entries
1903            * @param end the upper bound of the range of blogs entries (not inclusive)
1904            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1905            * @return the ordered range of matching blogs entries that the user has permission to view
1906            * @throws SystemException if a system exception occurred
1907            */
1908            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_LtD(
1909                    long groupId, java.util.Date displayDate, int start, int end,
1910                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1911                    throws com.liferay.portal.kernel.exception.SystemException {
1912                    return getPersistence()
1913                                       .filterFindByG_LtD(groupId, displayDate, start, end,
1914                            orderByComparator);
1915            }
1916    
1917            /**
1918            * 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;.
1919            *
1920            * @param entryId the primary key of the current blogs entry
1921            * @param groupId the group ID
1922            * @param displayDate the display date
1923            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1924            * @return the previous, current, and next blogs entry
1925            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
1926            * @throws SystemException if a system exception occurred
1927            */
1928            public static com.liferay.portlet.blogs.model.BlogsEntry[] filterFindByG_LtD_PrevAndNext(
1929                    long entryId, long groupId, java.util.Date displayDate,
1930                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1931                    throws com.liferay.portal.kernel.exception.SystemException,
1932                            com.liferay.portlet.blogs.NoSuchEntryException {
1933                    return getPersistence()
1934                                       .filterFindByG_LtD_PrevAndNext(entryId, groupId,
1935                            displayDate, orderByComparator);
1936            }
1937    
1938            /**
1939            * Removes all the blogs entries where groupId = &#63; and displayDate &lt; &#63; from the database.
1940            *
1941            * @param groupId the group ID
1942            * @param displayDate the display date
1943            * @throws SystemException if a system exception occurred
1944            */
1945            public static void removeByG_LtD(long groupId, java.util.Date displayDate)
1946                    throws com.liferay.portal.kernel.exception.SystemException {
1947                    getPersistence().removeByG_LtD(groupId, displayDate);
1948            }
1949    
1950            /**
1951            * Returns the number of blogs entries where groupId = &#63; and displayDate &lt; &#63;.
1952            *
1953            * @param groupId the group ID
1954            * @param displayDate the display date
1955            * @return the number of matching blogs entries
1956            * @throws SystemException if a system exception occurred
1957            */
1958            public static int countByG_LtD(long groupId, java.util.Date displayDate)
1959                    throws com.liferay.portal.kernel.exception.SystemException {
1960                    return getPersistence().countByG_LtD(groupId, displayDate);
1961            }
1962    
1963            /**
1964            * Returns the number of blogs entries that the user has permission to view where groupId = &#63; and displayDate &lt; &#63;.
1965            *
1966            * @param groupId the group ID
1967            * @param displayDate the display date
1968            * @return the number of matching blogs entries that the user has permission to view
1969            * @throws SystemException if a system exception occurred
1970            */
1971            public static int filterCountByG_LtD(long groupId,
1972                    java.util.Date displayDate)
1973                    throws com.liferay.portal.kernel.exception.SystemException {
1974                    return getPersistence().filterCountByG_LtD(groupId, displayDate);
1975            }
1976    
1977            /**
1978            * Returns all the blogs entries where groupId = &#63; and status &ne; &#63;.
1979            *
1980            * @param groupId the group ID
1981            * @param status the status
1982            * @return the matching blogs entries
1983            * @throws SystemException if a system exception occurred
1984            */
1985            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_NotS(
1986                    long groupId, int status)
1987                    throws com.liferay.portal.kernel.exception.SystemException {
1988                    return getPersistence().findByG_NotS(groupId, status);
1989            }
1990    
1991            /**
1992            * Returns a range of all the blogs entries where groupId = &#63; and status &ne; &#63;.
1993            *
1994            * <p>
1995            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1996            * </p>
1997            *
1998            * @param groupId the group ID
1999            * @param status the status
2000            * @param start the lower bound of the range of blogs entries
2001            * @param end the upper bound of the range of blogs entries (not inclusive)
2002            * @return the range of matching blogs entries
2003            * @throws SystemException if a system exception occurred
2004            */
2005            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_NotS(
2006                    long groupId, int status, int start, int end)
2007                    throws com.liferay.portal.kernel.exception.SystemException {
2008                    return getPersistence().findByG_NotS(groupId, status, start, end);
2009            }
2010    
2011            /**
2012            * Returns an ordered range of all the blogs entries where groupId = &#63; and status &ne; &#63;.
2013            *
2014            * <p>
2015            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2016            * </p>
2017            *
2018            * @param groupId the group ID
2019            * @param status the status
2020            * @param start the lower bound of the range of blogs entries
2021            * @param end the upper bound of the range of blogs entries (not inclusive)
2022            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2023            * @return the ordered range of matching blogs entries
2024            * @throws SystemException if a system exception occurred
2025            */
2026            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_NotS(
2027                    long groupId, int status, int start, int end,
2028                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2029                    throws com.liferay.portal.kernel.exception.SystemException {
2030                    return getPersistence()
2031                                       .findByG_NotS(groupId, status, start, end, orderByComparator);
2032            }
2033    
2034            /**
2035            * Returns the first blogs entry in the ordered set where groupId = &#63; and status &ne; &#63;.
2036            *
2037            * @param groupId the group ID
2038            * @param status the status
2039            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2040            * @return the first matching blogs entry
2041            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2042            * @throws SystemException if a system exception occurred
2043            */
2044            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_NotS_First(
2045                    long groupId, int status,
2046                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2047                    throws com.liferay.portal.kernel.exception.SystemException,
2048                            com.liferay.portlet.blogs.NoSuchEntryException {
2049                    return getPersistence()
2050                                       .findByG_NotS_First(groupId, status, orderByComparator);
2051            }
2052    
2053            /**
2054            * Returns the first blogs entry in the ordered set where groupId = &#63; and status &ne; &#63;.
2055            *
2056            * @param groupId the group ID
2057            * @param status the status
2058            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2059            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
2060            * @throws SystemException if a system exception occurred
2061            */
2062            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_NotS_First(
2063                    long groupId, int status,
2064                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2065                    throws com.liferay.portal.kernel.exception.SystemException {
2066                    return getPersistence()
2067                                       .fetchByG_NotS_First(groupId, status, orderByComparator);
2068            }
2069    
2070            /**
2071            * Returns the last blogs entry in the ordered set where groupId = &#63; and status &ne; &#63;.
2072            *
2073            * @param groupId the group ID
2074            * @param status the status
2075            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2076            * @return the last matching blogs entry
2077            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2078            * @throws SystemException if a system exception occurred
2079            */
2080            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_NotS_Last(
2081                    long groupId, int status,
2082                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2083                    throws com.liferay.portal.kernel.exception.SystemException,
2084                            com.liferay.portlet.blogs.NoSuchEntryException {
2085                    return getPersistence()
2086                                       .findByG_NotS_Last(groupId, status, orderByComparator);
2087            }
2088    
2089            /**
2090            * Returns the last blogs entry in the ordered set where groupId = &#63; and status &ne; &#63;.
2091            *
2092            * @param groupId the group ID
2093            * @param status the status
2094            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2095            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
2096            * @throws SystemException if a system exception occurred
2097            */
2098            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_NotS_Last(
2099                    long groupId, int status,
2100                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2101                    throws com.liferay.portal.kernel.exception.SystemException {
2102                    return getPersistence()
2103                                       .fetchByG_NotS_Last(groupId, status, orderByComparator);
2104            }
2105    
2106            /**
2107            * Returns the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and status &ne; &#63;.
2108            *
2109            * @param entryId the primary key of the current blogs entry
2110            * @param groupId the group ID
2111            * @param status the status
2112            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2113            * @return the previous, current, and next blogs entry
2114            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
2115            * @throws SystemException if a system exception occurred
2116            */
2117            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByG_NotS_PrevAndNext(
2118                    long entryId, long groupId, int status,
2119                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2120                    throws com.liferay.portal.kernel.exception.SystemException,
2121                            com.liferay.portlet.blogs.NoSuchEntryException {
2122                    return getPersistence()
2123                                       .findByG_NotS_PrevAndNext(entryId, groupId, status,
2124                            orderByComparator);
2125            }
2126    
2127            /**
2128            * Returns all the blogs entries that the user has permission to view where groupId = &#63; and status &ne; &#63;.
2129            *
2130            * @param groupId the group ID
2131            * @param status the status
2132            * @return the matching blogs entries that the user has permission to view
2133            * @throws SystemException if a system exception occurred
2134            */
2135            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_NotS(
2136                    long groupId, int status)
2137                    throws com.liferay.portal.kernel.exception.SystemException {
2138                    return getPersistence().filterFindByG_NotS(groupId, status);
2139            }
2140    
2141            /**
2142            * Returns a range of all the blogs entries that the user has permission to view where groupId = &#63; and status &ne; &#63;.
2143            *
2144            * <p>
2145            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2146            * </p>
2147            *
2148            * @param groupId the group ID
2149            * @param status the status
2150            * @param start the lower bound of the range of blogs entries
2151            * @param end the upper bound of the range of blogs entries (not inclusive)
2152            * @return the range of matching blogs entries that the user has permission to view
2153            * @throws SystemException if a system exception occurred
2154            */
2155            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_NotS(
2156                    long groupId, int status, int start, int end)
2157                    throws com.liferay.portal.kernel.exception.SystemException {
2158                    return getPersistence().filterFindByG_NotS(groupId, status, start, end);
2159            }
2160    
2161            /**
2162            * Returns an ordered range of all the blogs entries that the user has permissions to view where groupId = &#63; and status &ne; &#63;.
2163            *
2164            * <p>
2165            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2166            * </p>
2167            *
2168            * @param groupId the group ID
2169            * @param status the status
2170            * @param start the lower bound of the range of blogs entries
2171            * @param end the upper bound of the range of blogs entries (not inclusive)
2172            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2173            * @return the ordered range of matching blogs entries that the user has permission to view
2174            * @throws SystemException if a system exception occurred
2175            */
2176            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_NotS(
2177                    long groupId, int status, int start, int end,
2178                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2179                    throws com.liferay.portal.kernel.exception.SystemException {
2180                    return getPersistence()
2181                                       .filterFindByG_NotS(groupId, status, start, end,
2182                            orderByComparator);
2183            }
2184    
2185            /**
2186            * 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 &ne; &#63;.
2187            *
2188            * @param entryId the primary key of the current blogs entry
2189            * @param groupId the group ID
2190            * @param status the status
2191            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2192            * @return the previous, current, and next blogs entry
2193            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
2194            * @throws SystemException if a system exception occurred
2195            */
2196            public static com.liferay.portlet.blogs.model.BlogsEntry[] filterFindByG_NotS_PrevAndNext(
2197                    long entryId, long groupId, int status,
2198                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2199                    throws com.liferay.portal.kernel.exception.SystemException,
2200                            com.liferay.portlet.blogs.NoSuchEntryException {
2201                    return getPersistence()
2202                                       .filterFindByG_NotS_PrevAndNext(entryId, groupId, status,
2203                            orderByComparator);
2204            }
2205    
2206            /**
2207            * Removes all the blogs entries where groupId = &#63; and status &ne; &#63; from the database.
2208            *
2209            * @param groupId the group ID
2210            * @param status the status
2211            * @throws SystemException if a system exception occurred
2212            */
2213            public static void removeByG_NotS(long groupId, int status)
2214                    throws com.liferay.portal.kernel.exception.SystemException {
2215                    getPersistence().removeByG_NotS(groupId, status);
2216            }
2217    
2218            /**
2219            * Returns the number of blogs entries where groupId = &#63; and status &ne; &#63;.
2220            *
2221            * @param groupId the group ID
2222            * @param status the status
2223            * @return the number of matching blogs entries
2224            * @throws SystemException if a system exception occurred
2225            */
2226            public static int countByG_NotS(long groupId, int status)
2227                    throws com.liferay.portal.kernel.exception.SystemException {
2228                    return getPersistence().countByG_NotS(groupId, status);
2229            }
2230    
2231            /**
2232            * Returns the number of blogs entries that the user has permission to view where groupId = &#63; and status &ne; &#63;.
2233            *
2234            * @param groupId the group ID
2235            * @param status the status
2236            * @return the number of matching blogs entries that the user has permission to view
2237            * @throws SystemException if a system exception occurred
2238            */
2239            public static int filterCountByG_NotS(long groupId, int status)
2240                    throws com.liferay.portal.kernel.exception.SystemException {
2241                    return getPersistence().filterCountByG_NotS(groupId, status);
2242            }
2243    
2244            /**
2245            * Returns all the blogs entries where groupId = &#63; and status = &#63;.
2246            *
2247            * @param groupId the group ID
2248            * @param status the status
2249            * @return the matching blogs entries
2250            * @throws SystemException if a system exception occurred
2251            */
2252            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_S(
2253                    long groupId, int status)
2254                    throws com.liferay.portal.kernel.exception.SystemException {
2255                    return getPersistence().findByG_S(groupId, status);
2256            }
2257    
2258            /**
2259            * Returns a range of all the blogs entries where groupId = &#63; and status = &#63;.
2260            *
2261            * <p>
2262            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2263            * </p>
2264            *
2265            * @param groupId the group ID
2266            * @param status the status
2267            * @param start the lower bound of the range of blogs entries
2268            * @param end the upper bound of the range of blogs entries (not inclusive)
2269            * @return the range of matching blogs entries
2270            * @throws SystemException if a system exception occurred
2271            */
2272            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_S(
2273                    long groupId, int status, int start, int end)
2274                    throws com.liferay.portal.kernel.exception.SystemException {
2275                    return getPersistence().findByG_S(groupId, status, start, end);
2276            }
2277    
2278            /**
2279            * Returns an ordered range of all the blogs entries where groupId = &#63; and status = &#63;.
2280            *
2281            * <p>
2282            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2283            * </p>
2284            *
2285            * @param groupId the group ID
2286            * @param status the status
2287            * @param start the lower bound of the range of blogs entries
2288            * @param end the upper bound of the range of blogs entries (not inclusive)
2289            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2290            * @return the ordered range of matching blogs entries
2291            * @throws SystemException if a system exception occurred
2292            */
2293            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_S(
2294                    long groupId, int status, int start, int end,
2295                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2296                    throws com.liferay.portal.kernel.exception.SystemException {
2297                    return getPersistence()
2298                                       .findByG_S(groupId, status, start, end, orderByComparator);
2299            }
2300    
2301            /**
2302            * Returns the first blogs entry in the ordered set where groupId = &#63; and status = &#63;.
2303            *
2304            * @param groupId the group ID
2305            * @param status the status
2306            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2307            * @return the first matching blogs entry
2308            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2309            * @throws SystemException if a system exception occurred
2310            */
2311            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_S_First(
2312                    long groupId, int status,
2313                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2314                    throws com.liferay.portal.kernel.exception.SystemException,
2315                            com.liferay.portlet.blogs.NoSuchEntryException {
2316                    return getPersistence()
2317                                       .findByG_S_First(groupId, status, orderByComparator);
2318            }
2319    
2320            /**
2321            * Returns the first blogs entry in the ordered set where groupId = &#63; and status = &#63;.
2322            *
2323            * @param groupId the group ID
2324            * @param status the status
2325            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2326            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
2327            * @throws SystemException if a system exception occurred
2328            */
2329            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_S_First(
2330                    long groupId, int status,
2331                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2332                    throws com.liferay.portal.kernel.exception.SystemException {
2333                    return getPersistence()
2334                                       .fetchByG_S_First(groupId, status, orderByComparator);
2335            }
2336    
2337            /**
2338            * Returns the last blogs entry in the ordered set where groupId = &#63; and status = &#63;.
2339            *
2340            * @param groupId the group ID
2341            * @param status the status
2342            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2343            * @return the last matching blogs entry
2344            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2345            * @throws SystemException if a system exception occurred
2346            */
2347            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_S_Last(
2348                    long groupId, int status,
2349                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2350                    throws com.liferay.portal.kernel.exception.SystemException,
2351                            com.liferay.portlet.blogs.NoSuchEntryException {
2352                    return getPersistence()
2353                                       .findByG_S_Last(groupId, status, orderByComparator);
2354            }
2355    
2356            /**
2357            * Returns the last blogs entry in the ordered set where groupId = &#63; and status = &#63;.
2358            *
2359            * @param groupId the group ID
2360            * @param status the status
2361            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2362            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
2363            * @throws SystemException if a system exception occurred
2364            */
2365            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_S_Last(
2366                    long groupId, int status,
2367                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2368                    throws com.liferay.portal.kernel.exception.SystemException {
2369                    return getPersistence()
2370                                       .fetchByG_S_Last(groupId, status, orderByComparator);
2371            }
2372    
2373            /**
2374            * Returns the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and status = &#63;.
2375            *
2376            * @param entryId the primary key of the current blogs entry
2377            * @param groupId the group ID
2378            * @param status the status
2379            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2380            * @return the previous, current, and next blogs entry
2381            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
2382            * @throws SystemException if a system exception occurred
2383            */
2384            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByG_S_PrevAndNext(
2385                    long entryId, long groupId, int status,
2386                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2387                    throws com.liferay.portal.kernel.exception.SystemException,
2388                            com.liferay.portlet.blogs.NoSuchEntryException {
2389                    return getPersistence()
2390                                       .findByG_S_PrevAndNext(entryId, groupId, status,
2391                            orderByComparator);
2392            }
2393    
2394            /**
2395            * Returns all the blogs entries that the user has permission to view where groupId = &#63; and status = &#63;.
2396            *
2397            * @param groupId the group ID
2398            * @param status the status
2399            * @return the matching blogs entries that the user has permission to view
2400            * @throws SystemException if a system exception occurred
2401            */
2402            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_S(
2403                    long groupId, int status)
2404                    throws com.liferay.portal.kernel.exception.SystemException {
2405                    return getPersistence().filterFindByG_S(groupId, status);
2406            }
2407    
2408            /**
2409            * Returns a range of all the blogs entries that the user has permission to view where groupId = &#63; and status = &#63;.
2410            *
2411            * <p>
2412            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2413            * </p>
2414            *
2415            * @param groupId the group ID
2416            * @param status the status
2417            * @param start the lower bound of the range of blogs entries
2418            * @param end the upper bound of the range of blogs entries (not inclusive)
2419            * @return the range of matching blogs entries that the user has permission to view
2420            * @throws SystemException if a system exception occurred
2421            */
2422            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_S(
2423                    long groupId, int status, int start, int end)
2424                    throws com.liferay.portal.kernel.exception.SystemException {
2425                    return getPersistence().filterFindByG_S(groupId, status, start, end);
2426            }
2427    
2428            /**
2429            * Returns an ordered range of all the blogs entries that the user has permissions to view where groupId = &#63; and status = &#63;.
2430            *
2431            * <p>
2432            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2433            * </p>
2434            *
2435            * @param groupId the group ID
2436            * @param status the status
2437            * @param start the lower bound of the range of blogs entries
2438            * @param end the upper bound of the range of blogs entries (not inclusive)
2439            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2440            * @return the ordered range of matching blogs entries that the user has permission to view
2441            * @throws SystemException if a system exception occurred
2442            */
2443            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_S(
2444                    long groupId, int status, int start, int end,
2445                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2446                    throws com.liferay.portal.kernel.exception.SystemException {
2447                    return getPersistence()
2448                                       .filterFindByG_S(groupId, status, start, end,
2449                            orderByComparator);
2450            }
2451    
2452            /**
2453            * 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;.
2454            *
2455            * @param entryId the primary key of the current blogs entry
2456            * @param groupId the group ID
2457            * @param status the status
2458            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2459            * @return the previous, current, and next blogs entry
2460            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
2461            * @throws SystemException if a system exception occurred
2462            */
2463            public static com.liferay.portlet.blogs.model.BlogsEntry[] filterFindByG_S_PrevAndNext(
2464                    long entryId, long groupId, int status,
2465                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2466                    throws com.liferay.portal.kernel.exception.SystemException,
2467                            com.liferay.portlet.blogs.NoSuchEntryException {
2468                    return getPersistence()
2469                                       .filterFindByG_S_PrevAndNext(entryId, groupId, status,
2470                            orderByComparator);
2471            }
2472    
2473            /**
2474            * Removes all the blogs entries where groupId = &#63; and status = &#63; from the database.
2475            *
2476            * @param groupId the group ID
2477            * @param status the status
2478            * @throws SystemException if a system exception occurred
2479            */
2480            public static void removeByG_S(long groupId, int status)
2481                    throws com.liferay.portal.kernel.exception.SystemException {
2482                    getPersistence().removeByG_S(groupId, status);
2483            }
2484    
2485            /**
2486            * Returns the number of blogs entries where groupId = &#63; and status = &#63;.
2487            *
2488            * @param groupId the group ID
2489            * @param status the status
2490            * @return the number of matching blogs entries
2491            * @throws SystemException if a system exception occurred
2492            */
2493            public static int countByG_S(long groupId, int status)
2494                    throws com.liferay.portal.kernel.exception.SystemException {
2495                    return getPersistence().countByG_S(groupId, status);
2496            }
2497    
2498            /**
2499            * Returns the number of blogs entries that the user has permission to view where groupId = &#63; and status = &#63;.
2500            *
2501            * @param groupId the group ID
2502            * @param status the status
2503            * @return the number of matching blogs entries that the user has permission to view
2504            * @throws SystemException if a system exception occurred
2505            */
2506            public static int filterCountByG_S(long groupId, int status)
2507                    throws com.liferay.portal.kernel.exception.SystemException {
2508                    return getPersistence().filterCountByG_S(groupId, status);
2509            }
2510    
2511            /**
2512            * Returns all the blogs entries where displayDate &lt; &#63; and status = &#63;.
2513            *
2514            * @param displayDate the display date
2515            * @param status the status
2516            * @return the matching blogs entries
2517            * @throws SystemException if a system exception occurred
2518            */
2519            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByLtD_S(
2520                    java.util.Date displayDate, int status)
2521                    throws com.liferay.portal.kernel.exception.SystemException {
2522                    return getPersistence().findByLtD_S(displayDate, status);
2523            }
2524    
2525            /**
2526            * Returns a range of all the blogs entries where displayDate &lt; &#63; and status = &#63;.
2527            *
2528            * <p>
2529            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2530            * </p>
2531            *
2532            * @param displayDate the display date
2533            * @param status the status
2534            * @param start the lower bound of the range of blogs entries
2535            * @param end the upper bound of the range of blogs entries (not inclusive)
2536            * @return the range of matching blogs entries
2537            * @throws SystemException if a system exception occurred
2538            */
2539            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByLtD_S(
2540                    java.util.Date displayDate, int status, int start, int end)
2541                    throws com.liferay.portal.kernel.exception.SystemException {
2542                    return getPersistence().findByLtD_S(displayDate, status, start, end);
2543            }
2544    
2545            /**
2546            * Returns an ordered range of all the blogs entries where displayDate &lt; &#63; and status = &#63;.
2547            *
2548            * <p>
2549            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2550            * </p>
2551            *
2552            * @param displayDate the display date
2553            * @param status the status
2554            * @param start the lower bound of the range of blogs entries
2555            * @param end the upper bound of the range of blogs entries (not inclusive)
2556            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2557            * @return the ordered range of matching blogs entries
2558            * @throws SystemException if a system exception occurred
2559            */
2560            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByLtD_S(
2561                    java.util.Date displayDate, int status, int start, int end,
2562                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2563                    throws com.liferay.portal.kernel.exception.SystemException {
2564                    return getPersistence()
2565                                       .findByLtD_S(displayDate, status, start, end,
2566                            orderByComparator);
2567            }
2568    
2569            /**
2570            * Returns the first blogs entry in the ordered set where displayDate &lt; &#63; and status = &#63;.
2571            *
2572            * @param displayDate the display date
2573            * @param status the status
2574            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2575            * @return the first matching blogs entry
2576            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2577            * @throws SystemException if a system exception occurred
2578            */
2579            public static com.liferay.portlet.blogs.model.BlogsEntry findByLtD_S_First(
2580                    java.util.Date displayDate, int status,
2581                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2582                    throws com.liferay.portal.kernel.exception.SystemException,
2583                            com.liferay.portlet.blogs.NoSuchEntryException {
2584                    return getPersistence()
2585                                       .findByLtD_S_First(displayDate, status, orderByComparator);
2586            }
2587    
2588            /**
2589            * Returns the first blogs entry in the ordered set where displayDate &lt; &#63; and status = &#63;.
2590            *
2591            * @param displayDate the display date
2592            * @param status the status
2593            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2594            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
2595            * @throws SystemException if a system exception occurred
2596            */
2597            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByLtD_S_First(
2598                    java.util.Date displayDate, int status,
2599                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2600                    throws com.liferay.portal.kernel.exception.SystemException {
2601                    return getPersistence()
2602                                       .fetchByLtD_S_First(displayDate, status, orderByComparator);
2603            }
2604    
2605            /**
2606            * Returns the last blogs entry in the ordered set where displayDate &lt; &#63; and status = &#63;.
2607            *
2608            * @param displayDate the display date
2609            * @param status the status
2610            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2611            * @return the last matching blogs entry
2612            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2613            * @throws SystemException if a system exception occurred
2614            */
2615            public static com.liferay.portlet.blogs.model.BlogsEntry findByLtD_S_Last(
2616                    java.util.Date displayDate, int status,
2617                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2618                    throws com.liferay.portal.kernel.exception.SystemException,
2619                            com.liferay.portlet.blogs.NoSuchEntryException {
2620                    return getPersistence()
2621                                       .findByLtD_S_Last(displayDate, status, orderByComparator);
2622            }
2623    
2624            /**
2625            * Returns the last blogs entry in the ordered set where displayDate &lt; &#63; and status = &#63;.
2626            *
2627            * @param displayDate the display date
2628            * @param status the status
2629            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2630            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
2631            * @throws SystemException if a system exception occurred
2632            */
2633            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByLtD_S_Last(
2634                    java.util.Date displayDate, int status,
2635                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2636                    throws com.liferay.portal.kernel.exception.SystemException {
2637                    return getPersistence()
2638                                       .fetchByLtD_S_Last(displayDate, status, orderByComparator);
2639            }
2640    
2641            /**
2642            * Returns the blogs entries before and after the current blogs entry in the ordered set where displayDate &lt; &#63; and status = &#63;.
2643            *
2644            * @param entryId the primary key of the current blogs entry
2645            * @param displayDate the display date
2646            * @param status the status
2647            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2648            * @return the previous, current, and next blogs entry
2649            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
2650            * @throws SystemException if a system exception occurred
2651            */
2652            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByLtD_S_PrevAndNext(
2653                    long entryId, java.util.Date displayDate, int status,
2654                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2655                    throws com.liferay.portal.kernel.exception.SystemException,
2656                            com.liferay.portlet.blogs.NoSuchEntryException {
2657                    return getPersistence()
2658                                       .findByLtD_S_PrevAndNext(entryId, displayDate, status,
2659                            orderByComparator);
2660            }
2661    
2662            /**
2663            * Removes all the blogs entries where displayDate &lt; &#63; and status = &#63; from the database.
2664            *
2665            * @param displayDate the display date
2666            * @param status the status
2667            * @throws SystemException if a system exception occurred
2668            */
2669            public static void removeByLtD_S(java.util.Date displayDate, int status)
2670                    throws com.liferay.portal.kernel.exception.SystemException {
2671                    getPersistence().removeByLtD_S(displayDate, status);
2672            }
2673    
2674            /**
2675            * Returns the number of blogs entries where displayDate &lt; &#63; and status = &#63;.
2676            *
2677            * @param displayDate the display date
2678            * @param status the status
2679            * @return the number of matching blogs entries
2680            * @throws SystemException if a system exception occurred
2681            */
2682            public static int countByLtD_S(java.util.Date displayDate, int status)
2683                    throws com.liferay.portal.kernel.exception.SystemException {
2684                    return getPersistence().countByLtD_S(displayDate, status);
2685            }
2686    
2687            /**
2688            * Returns all the blogs entries where companyId = &#63; and userId = &#63; and status &ne; &#63;.
2689            *
2690            * @param companyId the company ID
2691            * @param userId the user ID
2692            * @param status the status
2693            * @return the matching blogs entries
2694            * @throws SystemException if a system exception occurred
2695            */
2696            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_U_NotS(
2697                    long companyId, long userId, int status)
2698                    throws com.liferay.portal.kernel.exception.SystemException {
2699                    return getPersistence().findByC_U_NotS(companyId, userId, status);
2700            }
2701    
2702            /**
2703            * Returns a range of all the blogs entries where companyId = &#63; and userId = &#63; and status &ne; &#63;.
2704            *
2705            * <p>
2706            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2707            * </p>
2708            *
2709            * @param companyId the company ID
2710            * @param userId the user ID
2711            * @param status the status
2712            * @param start the lower bound of the range of blogs entries
2713            * @param end the upper bound of the range of blogs entries (not inclusive)
2714            * @return the range of matching blogs entries
2715            * @throws SystemException if a system exception occurred
2716            */
2717            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_U_NotS(
2718                    long companyId, long userId, int status, int start, int end)
2719                    throws com.liferay.portal.kernel.exception.SystemException {
2720                    return getPersistence()
2721                                       .findByC_U_NotS(companyId, userId, status, start, end);
2722            }
2723    
2724            /**
2725            * Returns an ordered range of all the blogs entries where companyId = &#63; and userId = &#63; and status &ne; &#63;.
2726            *
2727            * <p>
2728            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2729            * </p>
2730            *
2731            * @param companyId the company ID
2732            * @param userId the user ID
2733            * @param status the status
2734            * @param start the lower bound of the range of blogs entries
2735            * @param end the upper bound of the range of blogs entries (not inclusive)
2736            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2737            * @return the ordered range of matching blogs entries
2738            * @throws SystemException if a system exception occurred
2739            */
2740            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_U_NotS(
2741                    long companyId, long userId, int status, int start, int end,
2742                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2743                    throws com.liferay.portal.kernel.exception.SystemException {
2744                    return getPersistence()
2745                                       .findByC_U_NotS(companyId, userId, status, start, end,
2746                            orderByComparator);
2747            }
2748    
2749            /**
2750            * Returns the first blogs entry in the ordered set where companyId = &#63; and userId = &#63; and status &ne; &#63;.
2751            *
2752            * @param companyId the company ID
2753            * @param userId the user ID
2754            * @param status the status
2755            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2756            * @return the first matching blogs entry
2757            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2758            * @throws SystemException if a system exception occurred
2759            */
2760            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_U_NotS_First(
2761                    long companyId, long userId, int status,
2762                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2763                    throws com.liferay.portal.kernel.exception.SystemException,
2764                            com.liferay.portlet.blogs.NoSuchEntryException {
2765                    return getPersistence()
2766                                       .findByC_U_NotS_First(companyId, userId, status,
2767                            orderByComparator);
2768            }
2769    
2770            /**
2771            * Returns the first blogs entry in the ordered set where companyId = &#63; and userId = &#63; and status &ne; &#63;.
2772            *
2773            * @param companyId the company ID
2774            * @param userId the user ID
2775            * @param status the status
2776            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2777            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
2778            * @throws SystemException if a system exception occurred
2779            */
2780            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByC_U_NotS_First(
2781                    long companyId, long userId, int status,
2782                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2783                    throws com.liferay.portal.kernel.exception.SystemException {
2784                    return getPersistence()
2785                                       .fetchByC_U_NotS_First(companyId, userId, status,
2786                            orderByComparator);
2787            }
2788    
2789            /**
2790            * Returns the last blogs entry in the ordered set where companyId = &#63; and userId = &#63; and status &ne; &#63;.
2791            *
2792            * @param companyId the company ID
2793            * @param userId the user ID
2794            * @param status the status
2795            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2796            * @return the last matching blogs entry
2797            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2798            * @throws SystemException if a system exception occurred
2799            */
2800            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_U_NotS_Last(
2801                    long companyId, long userId, int status,
2802                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2803                    throws com.liferay.portal.kernel.exception.SystemException,
2804                            com.liferay.portlet.blogs.NoSuchEntryException {
2805                    return getPersistence()
2806                                       .findByC_U_NotS_Last(companyId, userId, status,
2807                            orderByComparator);
2808            }
2809    
2810            /**
2811            * Returns the last blogs entry in the ordered set where companyId = &#63; and userId = &#63; and status &ne; &#63;.
2812            *
2813            * @param companyId the company ID
2814            * @param userId the user ID
2815            * @param status the status
2816            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2817            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
2818            * @throws SystemException if a system exception occurred
2819            */
2820            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByC_U_NotS_Last(
2821                    long companyId, long userId, int status,
2822                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2823                    throws com.liferay.portal.kernel.exception.SystemException {
2824                    return getPersistence()
2825                                       .fetchByC_U_NotS_Last(companyId, userId, status,
2826                            orderByComparator);
2827            }
2828    
2829            /**
2830            * Returns the blogs entries before and after the current blogs entry in the ordered set where companyId = &#63; and userId = &#63; and status &ne; &#63;.
2831            *
2832            * @param entryId the primary key of the current blogs entry
2833            * @param companyId the company ID
2834            * @param userId the user ID
2835            * @param status the status
2836            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2837            * @return the previous, current, and next blogs entry
2838            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
2839            * @throws SystemException if a system exception occurred
2840            */
2841            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByC_U_NotS_PrevAndNext(
2842                    long entryId, long companyId, long userId, int status,
2843                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2844                    throws com.liferay.portal.kernel.exception.SystemException,
2845                            com.liferay.portlet.blogs.NoSuchEntryException {
2846                    return getPersistence()
2847                                       .findByC_U_NotS_PrevAndNext(entryId, companyId, userId,
2848                            status, orderByComparator);
2849            }
2850    
2851            /**
2852            * Removes all the blogs entries where companyId = &#63; and userId = &#63; and status &ne; &#63; from the database.
2853            *
2854            * @param companyId the company ID
2855            * @param userId the user ID
2856            * @param status the status
2857            * @throws SystemException if a system exception occurred
2858            */
2859            public static void removeByC_U_NotS(long companyId, long userId, int status)
2860                    throws com.liferay.portal.kernel.exception.SystemException {
2861                    getPersistence().removeByC_U_NotS(companyId, userId, status);
2862            }
2863    
2864            /**
2865            * Returns the number of blogs entries where companyId = &#63; and userId = &#63; and status &ne; &#63;.
2866            *
2867            * @param companyId the company ID
2868            * @param userId the user ID
2869            * @param status the status
2870            * @return the number of matching blogs entries
2871            * @throws SystemException if a system exception occurred
2872            */
2873            public static int countByC_U_NotS(long companyId, long userId, int status)
2874                    throws com.liferay.portal.kernel.exception.SystemException {
2875                    return getPersistence().countByC_U_NotS(companyId, userId, status);
2876            }
2877    
2878            /**
2879            * Returns all the blogs entries where companyId = &#63; and userId = &#63; and status = &#63;.
2880            *
2881            * @param companyId the company ID
2882            * @param userId the user ID
2883            * @param status the status
2884            * @return the matching blogs entries
2885            * @throws SystemException if a system exception occurred
2886            */
2887            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_U_S(
2888                    long companyId, long userId, int status)
2889                    throws com.liferay.portal.kernel.exception.SystemException {
2890                    return getPersistence().findByC_U_S(companyId, userId, status);
2891            }
2892    
2893            /**
2894            * Returns a range of all the blogs entries where companyId = &#63; and userId = &#63; and status = &#63;.
2895            *
2896            * <p>
2897            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2898            * </p>
2899            *
2900            * @param companyId the company ID
2901            * @param userId the user ID
2902            * @param status the status
2903            * @param start the lower bound of the range of blogs entries
2904            * @param end the upper bound of the range of blogs entries (not inclusive)
2905            * @return the range of matching blogs entries
2906            * @throws SystemException if a system exception occurred
2907            */
2908            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_U_S(
2909                    long companyId, long userId, int status, int start, int end)
2910                    throws com.liferay.portal.kernel.exception.SystemException {
2911                    return getPersistence()
2912                                       .findByC_U_S(companyId, userId, status, start, end);
2913            }
2914    
2915            /**
2916            * Returns an ordered range of all the blogs entries where companyId = &#63; and userId = &#63; and status = &#63;.
2917            *
2918            * <p>
2919            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
2920            * </p>
2921            *
2922            * @param companyId the company ID
2923            * @param userId the user ID
2924            * @param status the status
2925            * @param start the lower bound of the range of blogs entries
2926            * @param end the upper bound of the range of blogs entries (not inclusive)
2927            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2928            * @return the ordered range of matching blogs entries
2929            * @throws SystemException if a system exception occurred
2930            */
2931            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_U_S(
2932                    long companyId, long userId, int status, int start, int end,
2933                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2934                    throws com.liferay.portal.kernel.exception.SystemException {
2935                    return getPersistence()
2936                                       .findByC_U_S(companyId, userId, status, start, end,
2937                            orderByComparator);
2938            }
2939    
2940            /**
2941            * Returns the first blogs entry in the ordered set where companyId = &#63; and userId = &#63; and status = &#63;.
2942            *
2943            * @param companyId the company ID
2944            * @param userId the user ID
2945            * @param status the status
2946            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2947            * @return the first matching blogs entry
2948            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2949            * @throws SystemException if a system exception occurred
2950            */
2951            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_U_S_First(
2952                    long companyId, long userId, int status,
2953                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2954                    throws com.liferay.portal.kernel.exception.SystemException,
2955                            com.liferay.portlet.blogs.NoSuchEntryException {
2956                    return getPersistence()
2957                                       .findByC_U_S_First(companyId, userId, status,
2958                            orderByComparator);
2959            }
2960    
2961            /**
2962            * Returns the first blogs entry in the ordered set where companyId = &#63; and userId = &#63; and status = &#63;.
2963            *
2964            * @param companyId the company ID
2965            * @param userId the user ID
2966            * @param status the status
2967            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2968            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
2969            * @throws SystemException if a system exception occurred
2970            */
2971            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByC_U_S_First(
2972                    long companyId, long userId, int status,
2973                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2974                    throws com.liferay.portal.kernel.exception.SystemException {
2975                    return getPersistence()
2976                                       .fetchByC_U_S_First(companyId, userId, status,
2977                            orderByComparator);
2978            }
2979    
2980            /**
2981            * Returns the last blogs entry in the ordered set where companyId = &#63; and userId = &#63; and status = &#63;.
2982            *
2983            * @param companyId the company ID
2984            * @param userId the user ID
2985            * @param status the status
2986            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2987            * @return the last matching blogs entry
2988            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2989            * @throws SystemException if a system exception occurred
2990            */
2991            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_U_S_Last(
2992                    long companyId, long userId, int status,
2993                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2994                    throws com.liferay.portal.kernel.exception.SystemException,
2995                            com.liferay.portlet.blogs.NoSuchEntryException {
2996                    return getPersistence()
2997                                       .findByC_U_S_Last(companyId, userId, status,
2998                            orderByComparator);
2999            }
3000    
3001            /**
3002            * Returns the last blogs entry in the ordered set where companyId = &#63; and userId = &#63; and status = &#63;.
3003            *
3004            * @param companyId the company ID
3005            * @param userId the user ID
3006            * @param status the status
3007            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3008            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
3009            * @throws SystemException if a system exception occurred
3010            */
3011            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByC_U_S_Last(
3012                    long companyId, long userId, int status,
3013                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3014                    throws com.liferay.portal.kernel.exception.SystemException {
3015                    return getPersistence()
3016                                       .fetchByC_U_S_Last(companyId, userId, status,
3017                            orderByComparator);
3018            }
3019    
3020            /**
3021            * Returns the blogs entries before and after the current blogs entry in the ordered set where companyId = &#63; and userId = &#63; and status = &#63;.
3022            *
3023            * @param entryId the primary key of the current blogs entry
3024            * @param companyId the company ID
3025            * @param userId the user ID
3026            * @param status the status
3027            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3028            * @return the previous, current, and next blogs entry
3029            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
3030            * @throws SystemException if a system exception occurred
3031            */
3032            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByC_U_S_PrevAndNext(
3033                    long entryId, long companyId, long userId, int status,
3034                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3035                    throws com.liferay.portal.kernel.exception.SystemException,
3036                            com.liferay.portlet.blogs.NoSuchEntryException {
3037                    return getPersistence()
3038                                       .findByC_U_S_PrevAndNext(entryId, companyId, userId, status,
3039                            orderByComparator);
3040            }
3041    
3042            /**
3043            * Removes all the blogs entries where companyId = &#63; and userId = &#63; and status = &#63; from the database.
3044            *
3045            * @param companyId the company ID
3046            * @param userId the user ID
3047            * @param status the status
3048            * @throws SystemException if a system exception occurred
3049            */
3050            public static void removeByC_U_S(long companyId, long userId, int status)
3051                    throws com.liferay.portal.kernel.exception.SystemException {
3052                    getPersistence().removeByC_U_S(companyId, userId, status);
3053            }
3054    
3055            /**
3056            * Returns the number of blogs entries where companyId = &#63; and userId = &#63; and status = &#63;.
3057            *
3058            * @param companyId the company ID
3059            * @param userId the user ID
3060            * @param status the status
3061            * @return the number of matching blogs entries
3062            * @throws SystemException if a system exception occurred
3063            */
3064            public static int countByC_U_S(long companyId, long userId, int status)
3065                    throws com.liferay.portal.kernel.exception.SystemException {
3066                    return getPersistence().countByC_U_S(companyId, userId, status);
3067            }
3068    
3069            /**
3070            * Returns all the blogs entries where companyId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
3071            *
3072            * @param companyId the company ID
3073            * @param displayDate the display date
3074            * @param status the status
3075            * @return the matching blogs entries
3076            * @throws SystemException if a system exception occurred
3077            */
3078            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_LtD_NotS(
3079                    long companyId, java.util.Date displayDate, int status)
3080                    throws com.liferay.portal.kernel.exception.SystemException {
3081                    return getPersistence().findByC_LtD_NotS(companyId, displayDate, status);
3082            }
3083    
3084            /**
3085            * Returns a range of all the blogs entries where companyId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
3086            *
3087            * <p>
3088            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3089            * </p>
3090            *
3091            * @param companyId the company ID
3092            * @param displayDate the display date
3093            * @param status the status
3094            * @param start the lower bound of the range of blogs entries
3095            * @param end the upper bound of the range of blogs entries (not inclusive)
3096            * @return the range of matching blogs entries
3097            * @throws SystemException if a system exception occurred
3098            */
3099            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_LtD_NotS(
3100                    long companyId, java.util.Date displayDate, int status, int start,
3101                    int end) throws com.liferay.portal.kernel.exception.SystemException {
3102                    return getPersistence()
3103                                       .findByC_LtD_NotS(companyId, displayDate, status, start, end);
3104            }
3105    
3106            /**
3107            * Returns an ordered range of all the blogs entries where companyId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
3108            *
3109            * <p>
3110            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3111            * </p>
3112            *
3113            * @param companyId the company ID
3114            * @param displayDate the display date
3115            * @param status the status
3116            * @param start the lower bound of the range of blogs entries
3117            * @param end the upper bound of the range of blogs entries (not inclusive)
3118            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3119            * @return the ordered range of matching blogs entries
3120            * @throws SystemException if a system exception occurred
3121            */
3122            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_LtD_NotS(
3123                    long companyId, java.util.Date displayDate, int status, int start,
3124                    int end,
3125                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3126                    throws com.liferay.portal.kernel.exception.SystemException {
3127                    return getPersistence()
3128                                       .findByC_LtD_NotS(companyId, displayDate, status, start,
3129                            end, orderByComparator);
3130            }
3131    
3132            /**
3133            * Returns the first blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
3134            *
3135            * @param companyId the company ID
3136            * @param displayDate the display date
3137            * @param status the status
3138            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3139            * @return the first matching blogs entry
3140            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
3141            * @throws SystemException if a system exception occurred
3142            */
3143            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_LtD_NotS_First(
3144                    long companyId, java.util.Date displayDate, int status,
3145                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3146                    throws com.liferay.portal.kernel.exception.SystemException,
3147                            com.liferay.portlet.blogs.NoSuchEntryException {
3148                    return getPersistence()
3149                                       .findByC_LtD_NotS_First(companyId, displayDate, status,
3150                            orderByComparator);
3151            }
3152    
3153            /**
3154            * Returns the first blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
3155            *
3156            * @param companyId the company ID
3157            * @param displayDate the display date
3158            * @param status the status
3159            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3160            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
3161            * @throws SystemException if a system exception occurred
3162            */
3163            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByC_LtD_NotS_First(
3164                    long companyId, java.util.Date displayDate, int status,
3165                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3166                    throws com.liferay.portal.kernel.exception.SystemException {
3167                    return getPersistence()
3168                                       .fetchByC_LtD_NotS_First(companyId, displayDate, status,
3169                            orderByComparator);
3170            }
3171    
3172            /**
3173            * Returns the last blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
3174            *
3175            * @param companyId the company ID
3176            * @param displayDate the display date
3177            * @param status the status
3178            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3179            * @return the last matching blogs entry
3180            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
3181            * @throws SystemException if a system exception occurred
3182            */
3183            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_LtD_NotS_Last(
3184                    long companyId, java.util.Date displayDate, int status,
3185                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3186                    throws com.liferay.portal.kernel.exception.SystemException,
3187                            com.liferay.portlet.blogs.NoSuchEntryException {
3188                    return getPersistence()
3189                                       .findByC_LtD_NotS_Last(companyId, displayDate, status,
3190                            orderByComparator);
3191            }
3192    
3193            /**
3194            * Returns the last blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
3195            *
3196            * @param companyId the company ID
3197            * @param displayDate the display date
3198            * @param status the status
3199            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3200            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
3201            * @throws SystemException if a system exception occurred
3202            */
3203            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByC_LtD_NotS_Last(
3204                    long companyId, java.util.Date displayDate, int status,
3205                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3206                    throws com.liferay.portal.kernel.exception.SystemException {
3207                    return getPersistence()
3208                                       .fetchByC_LtD_NotS_Last(companyId, displayDate, status,
3209                            orderByComparator);
3210            }
3211    
3212            /**
3213            * Returns the blogs entries before and after the current blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
3214            *
3215            * @param entryId the primary key of the current blogs entry
3216            * @param companyId the company ID
3217            * @param displayDate the display date
3218            * @param status the status
3219            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3220            * @return the previous, current, and next blogs entry
3221            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
3222            * @throws SystemException if a system exception occurred
3223            */
3224            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByC_LtD_NotS_PrevAndNext(
3225                    long entryId, long companyId, java.util.Date displayDate, int status,
3226                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3227                    throws com.liferay.portal.kernel.exception.SystemException,
3228                            com.liferay.portlet.blogs.NoSuchEntryException {
3229                    return getPersistence()
3230                                       .findByC_LtD_NotS_PrevAndNext(entryId, companyId,
3231                            displayDate, status, orderByComparator);
3232            }
3233    
3234            /**
3235            * Removes all the blogs entries where companyId = &#63; and displayDate &lt; &#63; and status &ne; &#63; from the database.
3236            *
3237            * @param companyId the company ID
3238            * @param displayDate the display date
3239            * @param status the status
3240            * @throws SystemException if a system exception occurred
3241            */
3242            public static void removeByC_LtD_NotS(long companyId,
3243                    java.util.Date displayDate, int status)
3244                    throws com.liferay.portal.kernel.exception.SystemException {
3245                    getPersistence().removeByC_LtD_NotS(companyId, displayDate, status);
3246            }
3247    
3248            /**
3249            * Returns the number of blogs entries where companyId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
3250            *
3251            * @param companyId the company ID
3252            * @param displayDate the display date
3253            * @param status the status
3254            * @return the number of matching blogs entries
3255            * @throws SystemException if a system exception occurred
3256            */
3257            public static int countByC_LtD_NotS(long companyId,
3258                    java.util.Date displayDate, int status)
3259                    throws com.liferay.portal.kernel.exception.SystemException {
3260                    return getPersistence().countByC_LtD_NotS(companyId, displayDate, status);
3261            }
3262    
3263            /**
3264            * Returns all the blogs entries where companyId = &#63; and displayDate &lt; &#63; and status = &#63;.
3265            *
3266            * @param companyId the company ID
3267            * @param displayDate the display date
3268            * @param status the status
3269            * @return the matching blogs entries
3270            * @throws SystemException if a system exception occurred
3271            */
3272            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_LtD_S(
3273                    long companyId, java.util.Date displayDate, int status)
3274                    throws com.liferay.portal.kernel.exception.SystemException {
3275                    return getPersistence().findByC_LtD_S(companyId, displayDate, status);
3276            }
3277    
3278            /**
3279            * Returns a range of all the blogs entries where companyId = &#63; and displayDate &lt; &#63; and status = &#63;.
3280            *
3281            * <p>
3282            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3283            * </p>
3284            *
3285            * @param companyId the company ID
3286            * @param displayDate the display date
3287            * @param status the status
3288            * @param start the lower bound of the range of blogs entries
3289            * @param end the upper bound of the range of blogs entries (not inclusive)
3290            * @return the range of matching blogs entries
3291            * @throws SystemException if a system exception occurred
3292            */
3293            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_LtD_S(
3294                    long companyId, java.util.Date displayDate, int status, int start,
3295                    int end) throws com.liferay.portal.kernel.exception.SystemException {
3296                    return getPersistence()
3297                                       .findByC_LtD_S(companyId, displayDate, status, start, end);
3298            }
3299    
3300            /**
3301            * Returns an ordered range of all the blogs entries where companyId = &#63; and displayDate &lt; &#63; and status = &#63;.
3302            *
3303            * <p>
3304            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3305            * </p>
3306            *
3307            * @param companyId the company ID
3308            * @param displayDate the display date
3309            * @param status the status
3310            * @param start the lower bound of the range of blogs entries
3311            * @param end the upper bound of the range of blogs entries (not inclusive)
3312            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3313            * @return the ordered range of matching blogs entries
3314            * @throws SystemException if a system exception occurred
3315            */
3316            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_LtD_S(
3317                    long companyId, java.util.Date displayDate, int status, int start,
3318                    int end,
3319                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3320                    throws com.liferay.portal.kernel.exception.SystemException {
3321                    return getPersistence()
3322                                       .findByC_LtD_S(companyId, displayDate, status, start, end,
3323                            orderByComparator);
3324            }
3325    
3326            /**
3327            * Returns the first blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63; and status = &#63;.
3328            *
3329            * @param companyId the company ID
3330            * @param displayDate the display date
3331            * @param status the status
3332            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3333            * @return the first matching blogs entry
3334            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
3335            * @throws SystemException if a system exception occurred
3336            */
3337            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_LtD_S_First(
3338                    long companyId, java.util.Date displayDate, int status,
3339                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3340                    throws com.liferay.portal.kernel.exception.SystemException,
3341                            com.liferay.portlet.blogs.NoSuchEntryException {
3342                    return getPersistence()
3343                                       .findByC_LtD_S_First(companyId, displayDate, status,
3344                            orderByComparator);
3345            }
3346    
3347            /**
3348            * Returns the first blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63; and status = &#63;.
3349            *
3350            * @param companyId the company ID
3351            * @param displayDate the display date
3352            * @param status the status
3353            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3354            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
3355            * @throws SystemException if a system exception occurred
3356            */
3357            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByC_LtD_S_First(
3358                    long companyId, java.util.Date displayDate, int status,
3359                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3360                    throws com.liferay.portal.kernel.exception.SystemException {
3361                    return getPersistence()
3362                                       .fetchByC_LtD_S_First(companyId, displayDate, status,
3363                            orderByComparator);
3364            }
3365    
3366            /**
3367            * Returns the last blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63; and status = &#63;.
3368            *
3369            * @param companyId the company ID
3370            * @param displayDate the display date
3371            * @param status the status
3372            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3373            * @return the last matching blogs entry
3374            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
3375            * @throws SystemException if a system exception occurred
3376            */
3377            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_LtD_S_Last(
3378                    long companyId, java.util.Date displayDate, int status,
3379                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3380                    throws com.liferay.portal.kernel.exception.SystemException,
3381                            com.liferay.portlet.blogs.NoSuchEntryException {
3382                    return getPersistence()
3383                                       .findByC_LtD_S_Last(companyId, displayDate, status,
3384                            orderByComparator);
3385            }
3386    
3387            /**
3388            * Returns the last blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63; and status = &#63;.
3389            *
3390            * @param companyId the company ID
3391            * @param displayDate the display date
3392            * @param status the status
3393            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3394            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
3395            * @throws SystemException if a system exception occurred
3396            */
3397            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByC_LtD_S_Last(
3398                    long companyId, java.util.Date displayDate, int status,
3399                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3400                    throws com.liferay.portal.kernel.exception.SystemException {
3401                    return getPersistence()
3402                                       .fetchByC_LtD_S_Last(companyId, displayDate, status,
3403                            orderByComparator);
3404            }
3405    
3406            /**
3407            * 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;.
3408            *
3409            * @param entryId the primary key of the current blogs entry
3410            * @param companyId the company ID
3411            * @param displayDate the display date
3412            * @param status the status
3413            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3414            * @return the previous, current, and next blogs entry
3415            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
3416            * @throws SystemException if a system exception occurred
3417            */
3418            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByC_LtD_S_PrevAndNext(
3419                    long entryId, long companyId, java.util.Date displayDate, int status,
3420                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3421                    throws com.liferay.portal.kernel.exception.SystemException,
3422                            com.liferay.portlet.blogs.NoSuchEntryException {
3423                    return getPersistence()
3424                                       .findByC_LtD_S_PrevAndNext(entryId, companyId, displayDate,
3425                            status, orderByComparator);
3426            }
3427    
3428            /**
3429            * Removes all the blogs entries where companyId = &#63; and displayDate &lt; &#63; and status = &#63; from the database.
3430            *
3431            * @param companyId the company ID
3432            * @param displayDate the display date
3433            * @param status the status
3434            * @throws SystemException if a system exception occurred
3435            */
3436            public static void removeByC_LtD_S(long companyId,
3437                    java.util.Date displayDate, int status)
3438                    throws com.liferay.portal.kernel.exception.SystemException {
3439                    getPersistence().removeByC_LtD_S(companyId, displayDate, status);
3440            }
3441    
3442            /**
3443            * Returns the number of blogs entries where companyId = &#63; and displayDate &lt; &#63; and status = &#63;.
3444            *
3445            * @param companyId the company ID
3446            * @param displayDate the display date
3447            * @param status the status
3448            * @return the number of matching blogs entries
3449            * @throws SystemException if a system exception occurred
3450            */
3451            public static int countByC_LtD_S(long companyId,
3452                    java.util.Date displayDate, int status)
3453                    throws com.liferay.portal.kernel.exception.SystemException {
3454                    return getPersistence().countByC_LtD_S(companyId, displayDate, status);
3455            }
3456    
3457            /**
3458            * Returns all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
3459            *
3460            * @param groupId the group ID
3461            * @param userId the user ID
3462            * @param displayDate the display date
3463            * @return the matching blogs entries
3464            * @throws SystemException if a system exception occurred
3465            */
3466            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_LtD(
3467                    long groupId, long userId, java.util.Date displayDate)
3468                    throws com.liferay.portal.kernel.exception.SystemException {
3469                    return getPersistence().findByG_U_LtD(groupId, userId, displayDate);
3470            }
3471    
3472            /**
3473            * Returns a range of all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
3474            *
3475            * <p>
3476            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3477            * </p>
3478            *
3479            * @param groupId the group ID
3480            * @param userId the user ID
3481            * @param displayDate the display date
3482            * @param start the lower bound of the range of blogs entries
3483            * @param end the upper bound of the range of blogs entries (not inclusive)
3484            * @return the range of matching blogs entries
3485            * @throws SystemException if a system exception occurred
3486            */
3487            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_LtD(
3488                    long groupId, long userId, java.util.Date displayDate, int start,
3489                    int end) throws com.liferay.portal.kernel.exception.SystemException {
3490                    return getPersistence()
3491                                       .findByG_U_LtD(groupId, userId, displayDate, start, end);
3492            }
3493    
3494            /**
3495            * Returns an ordered range of all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
3496            *
3497            * <p>
3498            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3499            * </p>
3500            *
3501            * @param groupId the group ID
3502            * @param userId the user ID
3503            * @param displayDate the display date
3504            * @param start the lower bound of the range of blogs entries
3505            * @param end the upper bound of the range of blogs entries (not inclusive)
3506            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3507            * @return the ordered range of matching blogs entries
3508            * @throws SystemException if a system exception occurred
3509            */
3510            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_LtD(
3511                    long groupId, long userId, java.util.Date displayDate, int start,
3512                    int end,
3513                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3514                    throws com.liferay.portal.kernel.exception.SystemException {
3515                    return getPersistence()
3516                                       .findByG_U_LtD(groupId, userId, displayDate, start, end,
3517                            orderByComparator);
3518            }
3519    
3520            /**
3521            * Returns the first blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
3522            *
3523            * @param groupId the group ID
3524            * @param userId the user ID
3525            * @param displayDate the display date
3526            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3527            * @return the first matching blogs entry
3528            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
3529            * @throws SystemException if a system exception occurred
3530            */
3531            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_U_LtD_First(
3532                    long groupId, long userId, java.util.Date displayDate,
3533                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3534                    throws com.liferay.portal.kernel.exception.SystemException,
3535                            com.liferay.portlet.blogs.NoSuchEntryException {
3536                    return getPersistence()
3537                                       .findByG_U_LtD_First(groupId, userId, displayDate,
3538                            orderByComparator);
3539            }
3540    
3541            /**
3542            * Returns the first blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
3543            *
3544            * @param groupId the group ID
3545            * @param userId the user ID
3546            * @param displayDate the display date
3547            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3548            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
3549            * @throws SystemException if a system exception occurred
3550            */
3551            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_U_LtD_First(
3552                    long groupId, long userId, java.util.Date displayDate,
3553                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3554                    throws com.liferay.portal.kernel.exception.SystemException {
3555                    return getPersistence()
3556                                       .fetchByG_U_LtD_First(groupId, userId, displayDate,
3557                            orderByComparator);
3558            }
3559    
3560            /**
3561            * Returns the last blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
3562            *
3563            * @param groupId the group ID
3564            * @param userId the user ID
3565            * @param displayDate the display date
3566            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3567            * @return the last matching blogs entry
3568            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
3569            * @throws SystemException if a system exception occurred
3570            */
3571            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_U_LtD_Last(
3572                    long groupId, long userId, java.util.Date displayDate,
3573                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3574                    throws com.liferay.portal.kernel.exception.SystemException,
3575                            com.liferay.portlet.blogs.NoSuchEntryException {
3576                    return getPersistence()
3577                                       .findByG_U_LtD_Last(groupId, userId, displayDate,
3578                            orderByComparator);
3579            }
3580    
3581            /**
3582            * Returns the last blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
3583            *
3584            * @param groupId the group ID
3585            * @param userId the user ID
3586            * @param displayDate the display date
3587            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3588            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
3589            * @throws SystemException if a system exception occurred
3590            */
3591            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_U_LtD_Last(
3592                    long groupId, long userId, java.util.Date displayDate,
3593                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3594                    throws com.liferay.portal.kernel.exception.SystemException {
3595                    return getPersistence()
3596                                       .fetchByG_U_LtD_Last(groupId, userId, displayDate,
3597                            orderByComparator);
3598            }
3599    
3600            /**
3601            * 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;.
3602            *
3603            * @param entryId the primary key of the current blogs entry
3604            * @param groupId the group ID
3605            * @param userId the user ID
3606            * @param displayDate the display date
3607            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3608            * @return the previous, current, and next blogs entry
3609            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
3610            * @throws SystemException if a system exception occurred
3611            */
3612            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByG_U_LtD_PrevAndNext(
3613                    long entryId, long groupId, long userId, java.util.Date displayDate,
3614                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3615                    throws com.liferay.portal.kernel.exception.SystemException,
3616                            com.liferay.portlet.blogs.NoSuchEntryException {
3617                    return getPersistence()
3618                                       .findByG_U_LtD_PrevAndNext(entryId, groupId, userId,
3619                            displayDate, orderByComparator);
3620            }
3621    
3622            /**
3623            * Returns all the blogs entries that the user has permission to view where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
3624            *
3625            * @param groupId the group ID
3626            * @param userId the user ID
3627            * @param displayDate the display date
3628            * @return the matching blogs entries that the user has permission to view
3629            * @throws SystemException if a system exception occurred
3630            */
3631            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_LtD(
3632                    long groupId, long userId, java.util.Date displayDate)
3633                    throws com.liferay.portal.kernel.exception.SystemException {
3634                    return getPersistence().filterFindByG_U_LtD(groupId, userId, displayDate);
3635            }
3636    
3637            /**
3638            * 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;.
3639            *
3640            * <p>
3641            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3642            * </p>
3643            *
3644            * @param groupId the group ID
3645            * @param userId the user ID
3646            * @param displayDate the display date
3647            * @param start the lower bound of the range of blogs entries
3648            * @param end the upper bound of the range of blogs entries (not inclusive)
3649            * @return the range of matching blogs entries that the user has permission to view
3650            * @throws SystemException if a system exception occurred
3651            */
3652            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_LtD(
3653                    long groupId, long userId, java.util.Date displayDate, int start,
3654                    int end) throws com.liferay.portal.kernel.exception.SystemException {
3655                    return getPersistence()
3656                                       .filterFindByG_U_LtD(groupId, userId, displayDate, start, end);
3657            }
3658    
3659            /**
3660            * 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;.
3661            *
3662            * <p>
3663            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3664            * </p>
3665            *
3666            * @param groupId the group ID
3667            * @param userId the user ID
3668            * @param displayDate the display date
3669            * @param start the lower bound of the range of blogs entries
3670            * @param end the upper bound of the range of blogs entries (not inclusive)
3671            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3672            * @return the ordered range of matching blogs entries that the user has permission to view
3673            * @throws SystemException if a system exception occurred
3674            */
3675            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_LtD(
3676                    long groupId, long userId, java.util.Date displayDate, int start,
3677                    int end,
3678                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3679                    throws com.liferay.portal.kernel.exception.SystemException {
3680                    return getPersistence()
3681                                       .filterFindByG_U_LtD(groupId, userId, displayDate, start,
3682                            end, orderByComparator);
3683            }
3684    
3685            /**
3686            * 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;.
3687            *
3688            * @param entryId the primary key of the current blogs entry
3689            * @param groupId the group ID
3690            * @param userId the user ID
3691            * @param displayDate the display date
3692            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3693            * @return the previous, current, and next blogs entry
3694            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
3695            * @throws SystemException if a system exception occurred
3696            */
3697            public static com.liferay.portlet.blogs.model.BlogsEntry[] filterFindByG_U_LtD_PrevAndNext(
3698                    long entryId, long groupId, long userId, java.util.Date displayDate,
3699                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3700                    throws com.liferay.portal.kernel.exception.SystemException,
3701                            com.liferay.portlet.blogs.NoSuchEntryException {
3702                    return getPersistence()
3703                                       .filterFindByG_U_LtD_PrevAndNext(entryId, groupId, userId,
3704                            displayDate, orderByComparator);
3705            }
3706    
3707            /**
3708            * Removes all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; from the database.
3709            *
3710            * @param groupId the group ID
3711            * @param userId the user ID
3712            * @param displayDate the display date
3713            * @throws SystemException if a system exception occurred
3714            */
3715            public static void removeByG_U_LtD(long groupId, long userId,
3716                    java.util.Date displayDate)
3717                    throws com.liferay.portal.kernel.exception.SystemException {
3718                    getPersistence().removeByG_U_LtD(groupId, userId, displayDate);
3719            }
3720    
3721            /**
3722            * Returns the number of blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
3723            *
3724            * @param groupId the group ID
3725            * @param userId the user ID
3726            * @param displayDate the display date
3727            * @return the number of matching blogs entries
3728            * @throws SystemException if a system exception occurred
3729            */
3730            public static int countByG_U_LtD(long groupId, long userId,
3731                    java.util.Date displayDate)
3732                    throws com.liferay.portal.kernel.exception.SystemException {
3733                    return getPersistence().countByG_U_LtD(groupId, userId, displayDate);
3734            }
3735    
3736            /**
3737            * Returns the number of blogs entries that the user has permission to view where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
3738            *
3739            * @param groupId the group ID
3740            * @param userId the user ID
3741            * @param displayDate the display date
3742            * @return the number of matching blogs entries that the user has permission to view
3743            * @throws SystemException if a system exception occurred
3744            */
3745            public static int filterCountByG_U_LtD(long groupId, long userId,
3746                    java.util.Date displayDate)
3747                    throws com.liferay.portal.kernel.exception.SystemException {
3748                    return getPersistence()
3749                                       .filterCountByG_U_LtD(groupId, userId, displayDate);
3750            }
3751    
3752            /**
3753            * Returns all the blogs entries where groupId = &#63; and userId = &#63; and status &ne; &#63;.
3754            *
3755            * @param groupId the group ID
3756            * @param userId the user ID
3757            * @param status the status
3758            * @return the matching blogs entries
3759            * @throws SystemException if a system exception occurred
3760            */
3761            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_NotS(
3762                    long groupId, long userId, int status)
3763                    throws com.liferay.portal.kernel.exception.SystemException {
3764                    return getPersistence().findByG_U_NotS(groupId, userId, status);
3765            }
3766    
3767            /**
3768            * Returns a range of all the blogs entries where groupId = &#63; and userId = &#63; and status &ne; &#63;.
3769            *
3770            * <p>
3771            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3772            * </p>
3773            *
3774            * @param groupId the group ID
3775            * @param userId the user ID
3776            * @param status the status
3777            * @param start the lower bound of the range of blogs entries
3778            * @param end the upper bound of the range of blogs entries (not inclusive)
3779            * @return the range of matching blogs entries
3780            * @throws SystemException if a system exception occurred
3781            */
3782            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_NotS(
3783                    long groupId, long userId, int status, int start, int end)
3784                    throws com.liferay.portal.kernel.exception.SystemException {
3785                    return getPersistence()
3786                                       .findByG_U_NotS(groupId, userId, status, start, end);
3787            }
3788    
3789            /**
3790            * Returns an ordered range of all the blogs entries where groupId = &#63; and userId = &#63; and status &ne; &#63;.
3791            *
3792            * <p>
3793            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3794            * </p>
3795            *
3796            * @param groupId the group ID
3797            * @param userId the user ID
3798            * @param status the status
3799            * @param start the lower bound of the range of blogs entries
3800            * @param end the upper bound of the range of blogs entries (not inclusive)
3801            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3802            * @return the ordered range of matching blogs entries
3803            * @throws SystemException if a system exception occurred
3804            */
3805            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_NotS(
3806                    long groupId, long userId, int status, int start, int end,
3807                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3808                    throws com.liferay.portal.kernel.exception.SystemException {
3809                    return getPersistence()
3810                                       .findByG_U_NotS(groupId, userId, status, start, end,
3811                            orderByComparator);
3812            }
3813    
3814            /**
3815            * Returns the first blogs entry in the ordered set where groupId = &#63; and userId = &#63; and status &ne; &#63;.
3816            *
3817            * @param groupId the group ID
3818            * @param userId the user ID
3819            * @param status the status
3820            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3821            * @return the first matching blogs entry
3822            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
3823            * @throws SystemException if a system exception occurred
3824            */
3825            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_U_NotS_First(
3826                    long groupId, long userId, int status,
3827                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3828                    throws com.liferay.portal.kernel.exception.SystemException,
3829                            com.liferay.portlet.blogs.NoSuchEntryException {
3830                    return getPersistence()
3831                                       .findByG_U_NotS_First(groupId, userId, status,
3832                            orderByComparator);
3833            }
3834    
3835            /**
3836            * Returns the first blogs entry in the ordered set where groupId = &#63; and userId = &#63; and status &ne; &#63;.
3837            *
3838            * @param groupId the group ID
3839            * @param userId the user ID
3840            * @param status the status
3841            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3842            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
3843            * @throws SystemException if a system exception occurred
3844            */
3845            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_U_NotS_First(
3846                    long groupId, long userId, int status,
3847                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3848                    throws com.liferay.portal.kernel.exception.SystemException {
3849                    return getPersistence()
3850                                       .fetchByG_U_NotS_First(groupId, userId, status,
3851                            orderByComparator);
3852            }
3853    
3854            /**
3855            * Returns the last blogs entry in the ordered set where groupId = &#63; and userId = &#63; and status &ne; &#63;.
3856            *
3857            * @param groupId the group ID
3858            * @param userId the user ID
3859            * @param status the status
3860            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3861            * @return the last matching blogs entry
3862            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
3863            * @throws SystemException if a system exception occurred
3864            */
3865            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_U_NotS_Last(
3866                    long groupId, long userId, int status,
3867                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3868                    throws com.liferay.portal.kernel.exception.SystemException,
3869                            com.liferay.portlet.blogs.NoSuchEntryException {
3870                    return getPersistence()
3871                                       .findByG_U_NotS_Last(groupId, userId, status,
3872                            orderByComparator);
3873            }
3874    
3875            /**
3876            * Returns the last blogs entry in the ordered set where groupId = &#63; and userId = &#63; and status &ne; &#63;.
3877            *
3878            * @param groupId the group ID
3879            * @param userId the user ID
3880            * @param status the status
3881            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3882            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
3883            * @throws SystemException if a system exception occurred
3884            */
3885            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_U_NotS_Last(
3886                    long groupId, long userId, int status,
3887                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3888                    throws com.liferay.portal.kernel.exception.SystemException {
3889                    return getPersistence()
3890                                       .fetchByG_U_NotS_Last(groupId, userId, status,
3891                            orderByComparator);
3892            }
3893    
3894            /**
3895            * Returns the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and userId = &#63; and status &ne; &#63;.
3896            *
3897            * @param entryId the primary key of the current blogs entry
3898            * @param groupId the group ID
3899            * @param userId the user ID
3900            * @param status the status
3901            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3902            * @return the previous, current, and next blogs entry
3903            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
3904            * @throws SystemException if a system exception occurred
3905            */
3906            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByG_U_NotS_PrevAndNext(
3907                    long entryId, long groupId, long userId, int status,
3908                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3909                    throws com.liferay.portal.kernel.exception.SystemException,
3910                            com.liferay.portlet.blogs.NoSuchEntryException {
3911                    return getPersistence()
3912                                       .findByG_U_NotS_PrevAndNext(entryId, groupId, userId,
3913                            status, orderByComparator);
3914            }
3915    
3916            /**
3917            * Returns all the blogs entries that the user has permission to view where groupId = &#63; and userId = &#63; and status &ne; &#63;.
3918            *
3919            * @param groupId the group ID
3920            * @param userId the user ID
3921            * @param status the status
3922            * @return the matching blogs entries that the user has permission to view
3923            * @throws SystemException if a system exception occurred
3924            */
3925            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_NotS(
3926                    long groupId, long userId, int status)
3927                    throws com.liferay.portal.kernel.exception.SystemException {
3928                    return getPersistence().filterFindByG_U_NotS(groupId, userId, status);
3929            }
3930    
3931            /**
3932            * Returns a range of all the blogs entries that the user has permission to view where groupId = &#63; and userId = &#63; and status &ne; &#63;.
3933            *
3934            * <p>
3935            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3936            * </p>
3937            *
3938            * @param groupId the group ID
3939            * @param userId the user ID
3940            * @param status the status
3941            * @param start the lower bound of the range of blogs entries
3942            * @param end the upper bound of the range of blogs entries (not inclusive)
3943            * @return the range of matching blogs entries that the user has permission to view
3944            * @throws SystemException if a system exception occurred
3945            */
3946            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_NotS(
3947                    long groupId, long userId, int status, int start, int end)
3948                    throws com.liferay.portal.kernel.exception.SystemException {
3949                    return getPersistence()
3950                                       .filterFindByG_U_NotS(groupId, userId, status, start, end);
3951            }
3952    
3953            /**
3954            * Returns an ordered range of all the blogs entries that the user has permissions to view where groupId = &#63; and userId = &#63; and status &ne; &#63;.
3955            *
3956            * <p>
3957            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
3958            * </p>
3959            *
3960            * @param groupId the group ID
3961            * @param userId the user ID
3962            * @param status the status
3963            * @param start the lower bound of the range of blogs entries
3964            * @param end the upper bound of the range of blogs entries (not inclusive)
3965            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3966            * @return the ordered range of matching blogs entries that the user has permission to view
3967            * @throws SystemException if a system exception occurred
3968            */
3969            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_NotS(
3970                    long groupId, long userId, int status, int start, int end,
3971                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3972                    throws com.liferay.portal.kernel.exception.SystemException {
3973                    return getPersistence()
3974                                       .filterFindByG_U_NotS(groupId, userId, status, start, end,
3975                            orderByComparator);
3976            }
3977    
3978            /**
3979            * 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 &ne; &#63;.
3980            *
3981            * @param entryId the primary key of the current blogs entry
3982            * @param groupId the group ID
3983            * @param userId the user ID
3984            * @param status the status
3985            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3986            * @return the previous, current, and next blogs entry
3987            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
3988            * @throws SystemException if a system exception occurred
3989            */
3990            public static com.liferay.portlet.blogs.model.BlogsEntry[] filterFindByG_U_NotS_PrevAndNext(
3991                    long entryId, long groupId, long userId, int status,
3992                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3993                    throws com.liferay.portal.kernel.exception.SystemException,
3994                            com.liferay.portlet.blogs.NoSuchEntryException {
3995                    return getPersistence()
3996                                       .filterFindByG_U_NotS_PrevAndNext(entryId, groupId, userId,
3997                            status, orderByComparator);
3998            }
3999    
4000            /**
4001            * Removes all the blogs entries where groupId = &#63; and userId = &#63; and status &ne; &#63; from the database.
4002            *
4003            * @param groupId the group ID
4004            * @param userId the user ID
4005            * @param status the status
4006            * @throws SystemException if a system exception occurred
4007            */
4008            public static void removeByG_U_NotS(long groupId, long userId, int status)
4009                    throws com.liferay.portal.kernel.exception.SystemException {
4010                    getPersistence().removeByG_U_NotS(groupId, userId, status);
4011            }
4012    
4013            /**
4014            * Returns the number of blogs entries where groupId = &#63; and userId = &#63; and status &ne; &#63;.
4015            *
4016            * @param groupId the group ID
4017            * @param userId the user ID
4018            * @param status the status
4019            * @return the number of matching blogs entries
4020            * @throws SystemException if a system exception occurred
4021            */
4022            public static int countByG_U_NotS(long groupId, long userId, int status)
4023                    throws com.liferay.portal.kernel.exception.SystemException {
4024                    return getPersistence().countByG_U_NotS(groupId, userId, status);
4025            }
4026    
4027            /**
4028            * Returns the number of blogs entries that the user has permission to view where groupId = &#63; and userId = &#63; and status &ne; &#63;.
4029            *
4030            * @param groupId the group ID
4031            * @param userId the user ID
4032            * @param status the status
4033            * @return the number of matching blogs entries that the user has permission to view
4034            * @throws SystemException if a system exception occurred
4035            */
4036            public static int filterCountByG_U_NotS(long groupId, long userId,
4037                    int status) throws com.liferay.portal.kernel.exception.SystemException {
4038                    return getPersistence().filterCountByG_U_NotS(groupId, userId, status);
4039            }
4040    
4041            /**
4042            * Returns all the blogs entries where groupId = &#63; and userId = &#63; and status = &#63;.
4043            *
4044            * @param groupId the group ID
4045            * @param userId the user ID
4046            * @param status the status
4047            * @return the matching blogs entries
4048            * @throws SystemException if a system exception occurred
4049            */
4050            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_S(
4051                    long groupId, long userId, int status)
4052                    throws com.liferay.portal.kernel.exception.SystemException {
4053                    return getPersistence().findByG_U_S(groupId, userId, status);
4054            }
4055    
4056            /**
4057            * Returns a range of all the blogs entries where groupId = &#63; and userId = &#63; and status = &#63;.
4058            *
4059            * <p>
4060            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4061            * </p>
4062            *
4063            * @param groupId the group ID
4064            * @param userId the user ID
4065            * @param status the status
4066            * @param start the lower bound of the range of blogs entries
4067            * @param end the upper bound of the range of blogs entries (not inclusive)
4068            * @return the range of matching blogs entries
4069            * @throws SystemException if a system exception occurred
4070            */
4071            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_S(
4072                    long groupId, long userId, int status, int start, int end)
4073                    throws com.liferay.portal.kernel.exception.SystemException {
4074                    return getPersistence().findByG_U_S(groupId, userId, status, start, end);
4075            }
4076    
4077            /**
4078            * Returns an ordered range of all the blogs entries where groupId = &#63; and userId = &#63; and status = &#63;.
4079            *
4080            * <p>
4081            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4082            * </p>
4083            *
4084            * @param groupId the group ID
4085            * @param userId the user ID
4086            * @param status the status
4087            * @param start the lower bound of the range of blogs entries
4088            * @param end the upper bound of the range of blogs entries (not inclusive)
4089            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4090            * @return the ordered range of matching blogs entries
4091            * @throws SystemException if a system exception occurred
4092            */
4093            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_S(
4094                    long groupId, long userId, int status, int start, int end,
4095                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4096                    throws com.liferay.portal.kernel.exception.SystemException {
4097                    return getPersistence()
4098                                       .findByG_U_S(groupId, userId, status, start, end,
4099                            orderByComparator);
4100            }
4101    
4102            /**
4103            * Returns the first blogs entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
4104            *
4105            * @param groupId the group ID
4106            * @param userId the user ID
4107            * @param status the status
4108            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4109            * @return the first matching blogs entry
4110            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
4111            * @throws SystemException if a system exception occurred
4112            */
4113            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_U_S_First(
4114                    long groupId, long userId, int status,
4115                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4116                    throws com.liferay.portal.kernel.exception.SystemException,
4117                            com.liferay.portlet.blogs.NoSuchEntryException {
4118                    return getPersistence()
4119                                       .findByG_U_S_First(groupId, userId, status, orderByComparator);
4120            }
4121    
4122            /**
4123            * Returns the first blogs entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
4124            *
4125            * @param groupId the group ID
4126            * @param userId the user ID
4127            * @param status the status
4128            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4129            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
4130            * @throws SystemException if a system exception occurred
4131            */
4132            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_U_S_First(
4133                    long groupId, long userId, int status,
4134                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4135                    throws com.liferay.portal.kernel.exception.SystemException {
4136                    return getPersistence()
4137                                       .fetchByG_U_S_First(groupId, userId, status,
4138                            orderByComparator);
4139            }
4140    
4141            /**
4142            * Returns the last blogs entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
4143            *
4144            * @param groupId the group ID
4145            * @param userId the user ID
4146            * @param status the status
4147            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4148            * @return the last matching blogs entry
4149            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
4150            * @throws SystemException if a system exception occurred
4151            */
4152            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_U_S_Last(
4153                    long groupId, long userId, int status,
4154                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4155                    throws com.liferay.portal.kernel.exception.SystemException,
4156                            com.liferay.portlet.blogs.NoSuchEntryException {
4157                    return getPersistence()
4158                                       .findByG_U_S_Last(groupId, userId, status, orderByComparator);
4159            }
4160    
4161            /**
4162            * Returns the last blogs entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
4163            *
4164            * @param groupId the group ID
4165            * @param userId the user ID
4166            * @param status the status
4167            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4168            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
4169            * @throws SystemException if a system exception occurred
4170            */
4171            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_U_S_Last(
4172                    long groupId, long userId, int status,
4173                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4174                    throws com.liferay.portal.kernel.exception.SystemException {
4175                    return getPersistence()
4176                                       .fetchByG_U_S_Last(groupId, userId, status, orderByComparator);
4177            }
4178    
4179            /**
4180            * Returns the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
4181            *
4182            * @param entryId the primary key of the current blogs entry
4183            * @param groupId the group ID
4184            * @param userId the user ID
4185            * @param status the status
4186            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4187            * @return the previous, current, and next blogs entry
4188            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
4189            * @throws SystemException if a system exception occurred
4190            */
4191            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByG_U_S_PrevAndNext(
4192                    long entryId, long groupId, long userId, int status,
4193                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4194                    throws com.liferay.portal.kernel.exception.SystemException,
4195                            com.liferay.portlet.blogs.NoSuchEntryException {
4196                    return getPersistence()
4197                                       .findByG_U_S_PrevAndNext(entryId, groupId, userId, status,
4198                            orderByComparator);
4199            }
4200    
4201            /**
4202            * Returns all the blogs entries that the user has permission to view where groupId = &#63; and userId = &#63; and status = &#63;.
4203            *
4204            * @param groupId the group ID
4205            * @param userId the user ID
4206            * @param status the status
4207            * @return the matching blogs entries that the user has permission to view
4208            * @throws SystemException if a system exception occurred
4209            */
4210            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_S(
4211                    long groupId, long userId, int status)
4212                    throws com.liferay.portal.kernel.exception.SystemException {
4213                    return getPersistence().filterFindByG_U_S(groupId, userId, status);
4214            }
4215    
4216            /**
4217            * Returns a range of all the blogs entries that the user has permission to view where groupId = &#63; and userId = &#63; and status = &#63;.
4218            *
4219            * <p>
4220            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4221            * </p>
4222            *
4223            * @param groupId the group ID
4224            * @param userId the user ID
4225            * @param status the status
4226            * @param start the lower bound of the range of blogs entries
4227            * @param end the upper bound of the range of blogs entries (not inclusive)
4228            * @return the range of matching blogs entries that the user has permission to view
4229            * @throws SystemException if a system exception occurred
4230            */
4231            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_S(
4232                    long groupId, long userId, int status, int start, int end)
4233                    throws com.liferay.portal.kernel.exception.SystemException {
4234                    return getPersistence()
4235                                       .filterFindByG_U_S(groupId, userId, status, start, end);
4236            }
4237    
4238            /**
4239            * 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;.
4240            *
4241            * <p>
4242            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4243            * </p>
4244            *
4245            * @param groupId the group ID
4246            * @param userId the user ID
4247            * @param status the status
4248            * @param start the lower bound of the range of blogs entries
4249            * @param end the upper bound of the range of blogs entries (not inclusive)
4250            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4251            * @return the ordered range of matching blogs entries that the user has permission to view
4252            * @throws SystemException if a system exception occurred
4253            */
4254            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_S(
4255                    long groupId, long userId, int status, int start, int end,
4256                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4257                    throws com.liferay.portal.kernel.exception.SystemException {
4258                    return getPersistence()
4259                                       .filterFindByG_U_S(groupId, userId, status, start, end,
4260                            orderByComparator);
4261            }
4262    
4263            /**
4264            * 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;.
4265            *
4266            * @param entryId the primary key of the current blogs entry
4267            * @param groupId the group ID
4268            * @param userId the user ID
4269            * @param status the status
4270            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4271            * @return the previous, current, and next blogs entry
4272            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
4273            * @throws SystemException if a system exception occurred
4274            */
4275            public static com.liferay.portlet.blogs.model.BlogsEntry[] filterFindByG_U_S_PrevAndNext(
4276                    long entryId, long groupId, long userId, int status,
4277                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4278                    throws com.liferay.portal.kernel.exception.SystemException,
4279                            com.liferay.portlet.blogs.NoSuchEntryException {
4280                    return getPersistence()
4281                                       .filterFindByG_U_S_PrevAndNext(entryId, groupId, userId,
4282                            status, orderByComparator);
4283            }
4284    
4285            /**
4286            * Removes all the blogs entries where groupId = &#63; and userId = &#63; and status = &#63; from the database.
4287            *
4288            * @param groupId the group ID
4289            * @param userId the user ID
4290            * @param status the status
4291            * @throws SystemException if a system exception occurred
4292            */
4293            public static void removeByG_U_S(long groupId, long userId, int status)
4294                    throws com.liferay.portal.kernel.exception.SystemException {
4295                    getPersistence().removeByG_U_S(groupId, userId, status);
4296            }
4297    
4298            /**
4299            * Returns the number of blogs entries where groupId = &#63; and userId = &#63; and status = &#63;.
4300            *
4301            * @param groupId the group ID
4302            * @param userId the user ID
4303            * @param status the status
4304            * @return the number of matching blogs entries
4305            * @throws SystemException if a system exception occurred
4306            */
4307            public static int countByG_U_S(long groupId, long userId, int status)
4308                    throws com.liferay.portal.kernel.exception.SystemException {
4309                    return getPersistence().countByG_U_S(groupId, userId, status);
4310            }
4311    
4312            /**
4313            * Returns the number of blogs entries that the user has permission to view where groupId = &#63; and userId = &#63; and status = &#63;.
4314            *
4315            * @param groupId the group ID
4316            * @param userId the user ID
4317            * @param status the status
4318            * @return the number of matching blogs entries that the user has permission to view
4319            * @throws SystemException if a system exception occurred
4320            */
4321            public static int filterCountByG_U_S(long groupId, long userId, int status)
4322                    throws com.liferay.portal.kernel.exception.SystemException {
4323                    return getPersistence().filterCountByG_U_S(groupId, userId, status);
4324            }
4325    
4326            /**
4327            * Returns all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
4328            *
4329            * @param groupId the group ID
4330            * @param displayDate the display date
4331            * @param status the status
4332            * @return the matching blogs entries
4333            * @throws SystemException if a system exception occurred
4334            */
4335            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_LtD_NotS(
4336                    long groupId, java.util.Date displayDate, int status)
4337                    throws com.liferay.portal.kernel.exception.SystemException {
4338                    return getPersistence().findByG_LtD_NotS(groupId, displayDate, status);
4339            }
4340    
4341            /**
4342            * Returns a range of all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
4343            *
4344            * <p>
4345            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4346            * </p>
4347            *
4348            * @param groupId the group ID
4349            * @param displayDate the display date
4350            * @param status the status
4351            * @param start the lower bound of the range of blogs entries
4352            * @param end the upper bound of the range of blogs entries (not inclusive)
4353            * @return the range of matching blogs entries
4354            * @throws SystemException if a system exception occurred
4355            */
4356            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_LtD_NotS(
4357                    long groupId, java.util.Date displayDate, int status, int start, int end)
4358                    throws com.liferay.portal.kernel.exception.SystemException {
4359                    return getPersistence()
4360                                       .findByG_LtD_NotS(groupId, displayDate, status, start, end);
4361            }
4362    
4363            /**
4364            * Returns an ordered range of all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
4365            *
4366            * <p>
4367            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4368            * </p>
4369            *
4370            * @param groupId the group ID
4371            * @param displayDate the display date
4372            * @param status the status
4373            * @param start the lower bound of the range of blogs entries
4374            * @param end the upper bound of the range of blogs entries (not inclusive)
4375            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4376            * @return the ordered range of matching blogs entries
4377            * @throws SystemException if a system exception occurred
4378            */
4379            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_LtD_NotS(
4380                    long groupId, java.util.Date displayDate, int status, int start,
4381                    int end,
4382                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4383                    throws com.liferay.portal.kernel.exception.SystemException {
4384                    return getPersistence()
4385                                       .findByG_LtD_NotS(groupId, displayDate, status, start, end,
4386                            orderByComparator);
4387            }
4388    
4389            /**
4390            * Returns the first blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
4391            *
4392            * @param groupId the group ID
4393            * @param displayDate the display date
4394            * @param status the status
4395            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4396            * @return the first matching blogs entry
4397            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
4398            * @throws SystemException if a system exception occurred
4399            */
4400            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_LtD_NotS_First(
4401                    long groupId, java.util.Date displayDate, int status,
4402                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4403                    throws com.liferay.portal.kernel.exception.SystemException,
4404                            com.liferay.portlet.blogs.NoSuchEntryException {
4405                    return getPersistence()
4406                                       .findByG_LtD_NotS_First(groupId, displayDate, status,
4407                            orderByComparator);
4408            }
4409    
4410            /**
4411            * Returns the first blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
4412            *
4413            * @param groupId the group ID
4414            * @param displayDate the display date
4415            * @param status the status
4416            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4417            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
4418            * @throws SystemException if a system exception occurred
4419            */
4420            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_LtD_NotS_First(
4421                    long groupId, java.util.Date displayDate, int status,
4422                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4423                    throws com.liferay.portal.kernel.exception.SystemException {
4424                    return getPersistence()
4425                                       .fetchByG_LtD_NotS_First(groupId, displayDate, status,
4426                            orderByComparator);
4427            }
4428    
4429            /**
4430            * Returns the last blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
4431            *
4432            * @param groupId the group ID
4433            * @param displayDate the display date
4434            * @param status the status
4435            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4436            * @return the last matching blogs entry
4437            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
4438            * @throws SystemException if a system exception occurred
4439            */
4440            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_LtD_NotS_Last(
4441                    long groupId, java.util.Date displayDate, int status,
4442                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4443                    throws com.liferay.portal.kernel.exception.SystemException,
4444                            com.liferay.portlet.blogs.NoSuchEntryException {
4445                    return getPersistence()
4446                                       .findByG_LtD_NotS_Last(groupId, displayDate, status,
4447                            orderByComparator);
4448            }
4449    
4450            /**
4451            * Returns the last blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
4452            *
4453            * @param groupId the group ID
4454            * @param displayDate the display date
4455            * @param status the status
4456            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4457            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
4458            * @throws SystemException if a system exception occurred
4459            */
4460            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_LtD_NotS_Last(
4461                    long groupId, java.util.Date displayDate, int status,
4462                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4463                    throws com.liferay.portal.kernel.exception.SystemException {
4464                    return getPersistence()
4465                                       .fetchByG_LtD_NotS_Last(groupId, displayDate, status,
4466                            orderByComparator);
4467            }
4468    
4469            /**
4470            * Returns the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
4471            *
4472            * @param entryId the primary key of the current blogs entry
4473            * @param groupId the group ID
4474            * @param displayDate the display date
4475            * @param status the status
4476            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4477            * @return the previous, current, and next blogs entry
4478            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
4479            * @throws SystemException if a system exception occurred
4480            */
4481            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByG_LtD_NotS_PrevAndNext(
4482                    long entryId, long groupId, java.util.Date displayDate, int status,
4483                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4484                    throws com.liferay.portal.kernel.exception.SystemException,
4485                            com.liferay.portlet.blogs.NoSuchEntryException {
4486                    return getPersistence()
4487                                       .findByG_LtD_NotS_PrevAndNext(entryId, groupId, displayDate,
4488                            status, orderByComparator);
4489            }
4490    
4491            /**
4492            * Returns all the blogs entries that the user has permission to view where groupId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
4493            *
4494            * @param groupId the group ID
4495            * @param displayDate the display date
4496            * @param status the status
4497            * @return the matching blogs entries that the user has permission to view
4498            * @throws SystemException if a system exception occurred
4499            */
4500            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_LtD_NotS(
4501                    long groupId, java.util.Date displayDate, int status)
4502                    throws com.liferay.portal.kernel.exception.SystemException {
4503                    return getPersistence()
4504                                       .filterFindByG_LtD_NotS(groupId, displayDate, status);
4505            }
4506    
4507            /**
4508            * Returns a range of all the blogs entries that the user has permission to view where groupId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
4509            *
4510            * <p>
4511            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4512            * </p>
4513            *
4514            * @param groupId the group ID
4515            * @param displayDate the display date
4516            * @param status the status
4517            * @param start the lower bound of the range of blogs entries
4518            * @param end the upper bound of the range of blogs entries (not inclusive)
4519            * @return the range of matching blogs entries that the user has permission to view
4520            * @throws SystemException if a system exception occurred
4521            */
4522            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_LtD_NotS(
4523                    long groupId, java.util.Date displayDate, int status, int start, int end)
4524                    throws com.liferay.portal.kernel.exception.SystemException {
4525                    return getPersistence()
4526                                       .filterFindByG_LtD_NotS(groupId, displayDate, status, start,
4527                            end);
4528            }
4529    
4530            /**
4531            * 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 &ne; &#63;.
4532            *
4533            * <p>
4534            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4535            * </p>
4536            *
4537            * @param groupId the group ID
4538            * @param displayDate the display date
4539            * @param status the status
4540            * @param start the lower bound of the range of blogs entries
4541            * @param end the upper bound of the range of blogs entries (not inclusive)
4542            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4543            * @return the ordered range of matching blogs entries that the user has permission to view
4544            * @throws SystemException if a system exception occurred
4545            */
4546            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_LtD_NotS(
4547                    long groupId, java.util.Date displayDate, int status, int start,
4548                    int end,
4549                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4550                    throws com.liferay.portal.kernel.exception.SystemException {
4551                    return getPersistence()
4552                                       .filterFindByG_LtD_NotS(groupId, displayDate, status, start,
4553                            end, orderByComparator);
4554            }
4555    
4556            /**
4557            * 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 &ne; &#63;.
4558            *
4559            * @param entryId the primary key of the current blogs entry
4560            * @param groupId the group ID
4561            * @param displayDate the display date
4562            * @param status the status
4563            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4564            * @return the previous, current, and next blogs entry
4565            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
4566            * @throws SystemException if a system exception occurred
4567            */
4568            public static com.liferay.portlet.blogs.model.BlogsEntry[] filterFindByG_LtD_NotS_PrevAndNext(
4569                    long entryId, long groupId, java.util.Date displayDate, int status,
4570                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4571                    throws com.liferay.portal.kernel.exception.SystemException,
4572                            com.liferay.portlet.blogs.NoSuchEntryException {
4573                    return getPersistence()
4574                                       .filterFindByG_LtD_NotS_PrevAndNext(entryId, groupId,
4575                            displayDate, status, orderByComparator);
4576            }
4577    
4578            /**
4579            * Removes all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status &ne; &#63; from the database.
4580            *
4581            * @param groupId the group ID
4582            * @param displayDate the display date
4583            * @param status the status
4584            * @throws SystemException if a system exception occurred
4585            */
4586            public static void removeByG_LtD_NotS(long groupId,
4587                    java.util.Date displayDate, int status)
4588                    throws com.liferay.portal.kernel.exception.SystemException {
4589                    getPersistence().removeByG_LtD_NotS(groupId, displayDate, status);
4590            }
4591    
4592            /**
4593            * Returns the number of blogs entries where groupId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
4594            *
4595            * @param groupId the group ID
4596            * @param displayDate the display date
4597            * @param status the status
4598            * @return the number of matching blogs entries
4599            * @throws SystemException if a system exception occurred
4600            */
4601            public static int countByG_LtD_NotS(long groupId,
4602                    java.util.Date displayDate, int status)
4603                    throws com.liferay.portal.kernel.exception.SystemException {
4604                    return getPersistence().countByG_LtD_NotS(groupId, displayDate, status);
4605            }
4606    
4607            /**
4608            * Returns the number of blogs entries that the user has permission to view where groupId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
4609            *
4610            * @param groupId the group ID
4611            * @param displayDate the display date
4612            * @param status the status
4613            * @return the number of matching blogs entries that the user has permission to view
4614            * @throws SystemException if a system exception occurred
4615            */
4616            public static int filterCountByG_LtD_NotS(long groupId,
4617                    java.util.Date displayDate, int status)
4618                    throws com.liferay.portal.kernel.exception.SystemException {
4619                    return getPersistence()
4620                                       .filterCountByG_LtD_NotS(groupId, displayDate, status);
4621            }
4622    
4623            /**
4624            * Returns all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
4625            *
4626            * @param groupId the group ID
4627            * @param displayDate the display date
4628            * @param status the status
4629            * @return the matching blogs entries
4630            * @throws SystemException if a system exception occurred
4631            */
4632            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_LtD_S(
4633                    long groupId, java.util.Date displayDate, int status)
4634                    throws com.liferay.portal.kernel.exception.SystemException {
4635                    return getPersistence().findByG_LtD_S(groupId, displayDate, status);
4636            }
4637    
4638            /**
4639            * Returns a range of all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
4640            *
4641            * <p>
4642            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4643            * </p>
4644            *
4645            * @param groupId the group ID
4646            * @param displayDate the display date
4647            * @param status the status
4648            * @param start the lower bound of the range of blogs entries
4649            * @param end the upper bound of the range of blogs entries (not inclusive)
4650            * @return the range of matching blogs entries
4651            * @throws SystemException if a system exception occurred
4652            */
4653            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_LtD_S(
4654                    long groupId, java.util.Date displayDate, int status, int start, int end)
4655                    throws com.liferay.portal.kernel.exception.SystemException {
4656                    return getPersistence()
4657                                       .findByG_LtD_S(groupId, displayDate, status, start, end);
4658            }
4659    
4660            /**
4661            * Returns an ordered range of all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
4662            *
4663            * <p>
4664            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4665            * </p>
4666            *
4667            * @param groupId the group ID
4668            * @param displayDate the display date
4669            * @param status the status
4670            * @param start the lower bound of the range of blogs entries
4671            * @param end the upper bound of the range of blogs entries (not inclusive)
4672            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4673            * @return the ordered range of matching blogs entries
4674            * @throws SystemException if a system exception occurred
4675            */
4676            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_LtD_S(
4677                    long groupId, java.util.Date displayDate, int status, int start,
4678                    int end,
4679                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4680                    throws com.liferay.portal.kernel.exception.SystemException {
4681                    return getPersistence()
4682                                       .findByG_LtD_S(groupId, displayDate, status, start, end,
4683                            orderByComparator);
4684            }
4685    
4686            /**
4687            * Returns the first blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
4688            *
4689            * @param groupId the group ID
4690            * @param displayDate the display date
4691            * @param status the status
4692            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4693            * @return the first matching blogs entry
4694            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
4695            * @throws SystemException if a system exception occurred
4696            */
4697            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_LtD_S_First(
4698                    long groupId, java.util.Date displayDate, int status,
4699                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4700                    throws com.liferay.portal.kernel.exception.SystemException,
4701                            com.liferay.portlet.blogs.NoSuchEntryException {
4702                    return getPersistence()
4703                                       .findByG_LtD_S_First(groupId, displayDate, status,
4704                            orderByComparator);
4705            }
4706    
4707            /**
4708            * Returns the first blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
4709            *
4710            * @param groupId the group ID
4711            * @param displayDate the display date
4712            * @param status the status
4713            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4714            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
4715            * @throws SystemException if a system exception occurred
4716            */
4717            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_LtD_S_First(
4718                    long groupId, java.util.Date displayDate, int status,
4719                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4720                    throws com.liferay.portal.kernel.exception.SystemException {
4721                    return getPersistence()
4722                                       .fetchByG_LtD_S_First(groupId, displayDate, status,
4723                            orderByComparator);
4724            }
4725    
4726            /**
4727            * Returns the last blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
4728            *
4729            * @param groupId the group ID
4730            * @param displayDate the display date
4731            * @param status the status
4732            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4733            * @return the last matching blogs entry
4734            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
4735            * @throws SystemException if a system exception occurred
4736            */
4737            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_LtD_S_Last(
4738                    long groupId, java.util.Date displayDate, int status,
4739                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4740                    throws com.liferay.portal.kernel.exception.SystemException,
4741                            com.liferay.portlet.blogs.NoSuchEntryException {
4742                    return getPersistence()
4743                                       .findByG_LtD_S_Last(groupId, displayDate, status,
4744                            orderByComparator);
4745            }
4746    
4747            /**
4748            * Returns the last blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
4749            *
4750            * @param groupId the group ID
4751            * @param displayDate the display date
4752            * @param status the status
4753            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4754            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
4755            * @throws SystemException if a system exception occurred
4756            */
4757            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_LtD_S_Last(
4758                    long groupId, java.util.Date displayDate, int status,
4759                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4760                    throws com.liferay.portal.kernel.exception.SystemException {
4761                    return getPersistence()
4762                                       .fetchByG_LtD_S_Last(groupId, displayDate, status,
4763                            orderByComparator);
4764            }
4765    
4766            /**
4767            * 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;.
4768            *
4769            * @param entryId the primary key of the current blogs entry
4770            * @param groupId the group ID
4771            * @param displayDate the display date
4772            * @param status the status
4773            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4774            * @return the previous, current, and next blogs entry
4775            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
4776            * @throws SystemException if a system exception occurred
4777            */
4778            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByG_LtD_S_PrevAndNext(
4779                    long entryId, long groupId, java.util.Date displayDate, int status,
4780                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4781                    throws com.liferay.portal.kernel.exception.SystemException,
4782                            com.liferay.portlet.blogs.NoSuchEntryException {
4783                    return getPersistence()
4784                                       .findByG_LtD_S_PrevAndNext(entryId, groupId, displayDate,
4785                            status, orderByComparator);
4786            }
4787    
4788            /**
4789            * Returns all the blogs entries that the user has permission to view where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
4790            *
4791            * @param groupId the group ID
4792            * @param displayDate the display date
4793            * @param status the status
4794            * @return the matching blogs entries that the user has permission to view
4795            * @throws SystemException if a system exception occurred
4796            */
4797            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_LtD_S(
4798                    long groupId, java.util.Date displayDate, int status)
4799                    throws com.liferay.portal.kernel.exception.SystemException {
4800                    return getPersistence().filterFindByG_LtD_S(groupId, displayDate, status);
4801            }
4802    
4803            /**
4804            * 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;.
4805            *
4806            * <p>
4807            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4808            * </p>
4809            *
4810            * @param groupId the group ID
4811            * @param displayDate the display date
4812            * @param status the status
4813            * @param start the lower bound of the range of blogs entries
4814            * @param end the upper bound of the range of blogs entries (not inclusive)
4815            * @return the range of matching blogs entries that the user has permission to view
4816            * @throws SystemException if a system exception occurred
4817            */
4818            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_LtD_S(
4819                    long groupId, java.util.Date displayDate, int status, int start, int end)
4820                    throws com.liferay.portal.kernel.exception.SystemException {
4821                    return getPersistence()
4822                                       .filterFindByG_LtD_S(groupId, displayDate, status, start, end);
4823            }
4824    
4825            /**
4826            * 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;.
4827            *
4828            * <p>
4829            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4830            * </p>
4831            *
4832            * @param groupId the group ID
4833            * @param displayDate the display date
4834            * @param status the status
4835            * @param start the lower bound of the range of blogs entries
4836            * @param end the upper bound of the range of blogs entries (not inclusive)
4837            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4838            * @return the ordered range of matching blogs entries that the user has permission to view
4839            * @throws SystemException if a system exception occurred
4840            */
4841            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_LtD_S(
4842                    long groupId, java.util.Date displayDate, int status, int start,
4843                    int end,
4844                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4845                    throws com.liferay.portal.kernel.exception.SystemException {
4846                    return getPersistence()
4847                                       .filterFindByG_LtD_S(groupId, displayDate, status, start,
4848                            end, orderByComparator);
4849            }
4850    
4851            /**
4852            * 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;.
4853            *
4854            * @param entryId the primary key of the current blogs entry
4855            * @param groupId the group ID
4856            * @param displayDate the display date
4857            * @param status the status
4858            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4859            * @return the previous, current, and next blogs entry
4860            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
4861            * @throws SystemException if a system exception occurred
4862            */
4863            public static com.liferay.portlet.blogs.model.BlogsEntry[] filterFindByG_LtD_S_PrevAndNext(
4864                    long entryId, long groupId, java.util.Date displayDate, int status,
4865                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4866                    throws com.liferay.portal.kernel.exception.SystemException,
4867                            com.liferay.portlet.blogs.NoSuchEntryException {
4868                    return getPersistence()
4869                                       .filterFindByG_LtD_S_PrevAndNext(entryId, groupId,
4870                            displayDate, status, orderByComparator);
4871            }
4872    
4873            /**
4874            * Removes all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status = &#63; from the database.
4875            *
4876            * @param groupId the group ID
4877            * @param displayDate the display date
4878            * @param status the status
4879            * @throws SystemException if a system exception occurred
4880            */
4881            public static void removeByG_LtD_S(long groupId,
4882                    java.util.Date displayDate, int status)
4883                    throws com.liferay.portal.kernel.exception.SystemException {
4884                    getPersistence().removeByG_LtD_S(groupId, displayDate, status);
4885            }
4886    
4887            /**
4888            * Returns the number of blogs entries where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
4889            *
4890            * @param groupId the group ID
4891            * @param displayDate the display date
4892            * @param status the status
4893            * @return the number of matching blogs entries
4894            * @throws SystemException if a system exception occurred
4895            */
4896            public static int countByG_LtD_S(long groupId, java.util.Date displayDate,
4897                    int status) throws com.liferay.portal.kernel.exception.SystemException {
4898                    return getPersistence().countByG_LtD_S(groupId, displayDate, status);
4899            }
4900    
4901            /**
4902            * Returns the number of blogs entries that the user has permission to view where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
4903            *
4904            * @param groupId the group ID
4905            * @param displayDate the display date
4906            * @param status the status
4907            * @return the number of matching blogs entries that the user has permission to view
4908            * @throws SystemException if a system exception occurred
4909            */
4910            public static int filterCountByG_LtD_S(long groupId,
4911                    java.util.Date displayDate, int status)
4912                    throws com.liferay.portal.kernel.exception.SystemException {
4913                    return getPersistence()
4914                                       .filterCountByG_LtD_S(groupId, displayDate, status);
4915            }
4916    
4917            /**
4918            * Returns all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
4919            *
4920            * @param groupId the group ID
4921            * @param userId the user ID
4922            * @param displayDate the display date
4923            * @param status the status
4924            * @return the matching blogs entries
4925            * @throws SystemException if a system exception occurred
4926            */
4927            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_LtD_NotS(
4928                    long groupId, long userId, java.util.Date displayDate, int status)
4929                    throws com.liferay.portal.kernel.exception.SystemException {
4930                    return getPersistence()
4931                                       .findByG_U_LtD_NotS(groupId, userId, displayDate, status);
4932            }
4933    
4934            /**
4935            * Returns a range of all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
4936            *
4937            * <p>
4938            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4939            * </p>
4940            *
4941            * @param groupId the group ID
4942            * @param userId the user ID
4943            * @param displayDate the display date
4944            * @param status the status
4945            * @param start the lower bound of the range of blogs entries
4946            * @param end the upper bound of the range of blogs entries (not inclusive)
4947            * @return the range of matching blogs entries
4948            * @throws SystemException if a system exception occurred
4949            */
4950            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_LtD_NotS(
4951                    long groupId, long userId, java.util.Date displayDate, int status,
4952                    int start, int end)
4953                    throws com.liferay.portal.kernel.exception.SystemException {
4954                    return getPersistence()
4955                                       .findByG_U_LtD_NotS(groupId, userId, displayDate, status,
4956                            start, end);
4957            }
4958    
4959            /**
4960            * Returns an ordered range of all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
4961            *
4962            * <p>
4963            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
4964            * </p>
4965            *
4966            * @param groupId the group ID
4967            * @param userId the user ID
4968            * @param displayDate the display date
4969            * @param status the status
4970            * @param start the lower bound of the range of blogs entries
4971            * @param end the upper bound of the range of blogs entries (not inclusive)
4972            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4973            * @return the ordered range of matching blogs entries
4974            * @throws SystemException if a system exception occurred
4975            */
4976            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_LtD_NotS(
4977                    long groupId, long userId, java.util.Date displayDate, int status,
4978                    int start, int end,
4979                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4980                    throws com.liferay.portal.kernel.exception.SystemException {
4981                    return getPersistence()
4982                                       .findByG_U_LtD_NotS(groupId, userId, displayDate, status,
4983                            start, end, orderByComparator);
4984            }
4985    
4986            /**
4987            * Returns the first blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
4988            *
4989            * @param groupId the group ID
4990            * @param userId the user ID
4991            * @param displayDate the display date
4992            * @param status the status
4993            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4994            * @return the first matching blogs entry
4995            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
4996            * @throws SystemException if a system exception occurred
4997            */
4998            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_U_LtD_NotS_First(
4999                    long groupId, long userId, java.util.Date displayDate, int status,
5000                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5001                    throws com.liferay.portal.kernel.exception.SystemException,
5002                            com.liferay.portlet.blogs.NoSuchEntryException {
5003                    return getPersistence()
5004                                       .findByG_U_LtD_NotS_First(groupId, userId, displayDate,
5005                            status, orderByComparator);
5006            }
5007    
5008            /**
5009            * Returns the first blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
5010            *
5011            * @param groupId the group ID
5012            * @param userId the user ID
5013            * @param displayDate the display date
5014            * @param status the status
5015            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5016            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
5017            * @throws SystemException if a system exception occurred
5018            */
5019            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_U_LtD_NotS_First(
5020                    long groupId, long userId, java.util.Date displayDate, int status,
5021                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5022                    throws com.liferay.portal.kernel.exception.SystemException {
5023                    return getPersistence()
5024                                       .fetchByG_U_LtD_NotS_First(groupId, userId, displayDate,
5025                            status, orderByComparator);
5026            }
5027    
5028            /**
5029            * Returns the last blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
5030            *
5031            * @param groupId the group ID
5032            * @param userId the user ID
5033            * @param displayDate the display date
5034            * @param status the status
5035            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5036            * @return the last matching blogs entry
5037            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
5038            * @throws SystemException if a system exception occurred
5039            */
5040            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_U_LtD_NotS_Last(
5041                    long groupId, long userId, java.util.Date displayDate, int status,
5042                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5043                    throws com.liferay.portal.kernel.exception.SystemException,
5044                            com.liferay.portlet.blogs.NoSuchEntryException {
5045                    return getPersistence()
5046                                       .findByG_U_LtD_NotS_Last(groupId, userId, displayDate,
5047                            status, orderByComparator);
5048            }
5049    
5050            /**
5051            * Returns the last blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
5052            *
5053            * @param groupId the group ID
5054            * @param userId the user ID
5055            * @param displayDate the display date
5056            * @param status the status
5057            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5058            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
5059            * @throws SystemException if a system exception occurred
5060            */
5061            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_U_LtD_NotS_Last(
5062                    long groupId, long userId, java.util.Date displayDate, int status,
5063                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5064                    throws com.liferay.portal.kernel.exception.SystemException {
5065                    return getPersistence()
5066                                       .fetchByG_U_LtD_NotS_Last(groupId, userId, displayDate,
5067                            status, orderByComparator);
5068            }
5069    
5070            /**
5071            * 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 &ne; &#63;.
5072            *
5073            * @param entryId the primary key of the current blogs entry
5074            * @param groupId the group ID
5075            * @param userId the user ID
5076            * @param displayDate the display date
5077            * @param status the status
5078            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5079            * @return the previous, current, and next blogs entry
5080            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
5081            * @throws SystemException if a system exception occurred
5082            */
5083            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByG_U_LtD_NotS_PrevAndNext(
5084                    long entryId, long groupId, long userId, java.util.Date displayDate,
5085                    int status,
5086                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5087                    throws com.liferay.portal.kernel.exception.SystemException,
5088                            com.liferay.portlet.blogs.NoSuchEntryException {
5089                    return getPersistence()
5090                                       .findByG_U_LtD_NotS_PrevAndNext(entryId, groupId, userId,
5091                            displayDate, status, orderByComparator);
5092            }
5093    
5094            /**
5095            * Returns all the blogs entries that the user has permission to view where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
5096            *
5097            * @param groupId the group ID
5098            * @param userId the user ID
5099            * @param displayDate the display date
5100            * @param status the status
5101            * @return the matching blogs entries that the user has permission to view
5102            * @throws SystemException if a system exception occurred
5103            */
5104            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_LtD_NotS(
5105                    long groupId, long userId, java.util.Date displayDate, int status)
5106                    throws com.liferay.portal.kernel.exception.SystemException {
5107                    return getPersistence()
5108                                       .filterFindByG_U_LtD_NotS(groupId, userId, displayDate,
5109                            status);
5110            }
5111    
5112            /**
5113            * 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 &ne; &#63;.
5114            *
5115            * <p>
5116            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5117            * </p>
5118            *
5119            * @param groupId the group ID
5120            * @param userId the user ID
5121            * @param displayDate the display date
5122            * @param status the status
5123            * @param start the lower bound of the range of blogs entries
5124            * @param end the upper bound of the range of blogs entries (not inclusive)
5125            * @return the range of matching blogs entries that the user has permission to view
5126            * @throws SystemException if a system exception occurred
5127            */
5128            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_LtD_NotS(
5129                    long groupId, long userId, java.util.Date displayDate, int status,
5130                    int start, int end)
5131                    throws com.liferay.portal.kernel.exception.SystemException {
5132                    return getPersistence()
5133                                       .filterFindByG_U_LtD_NotS(groupId, userId, displayDate,
5134                            status, start, end);
5135            }
5136    
5137            /**
5138            * 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 &ne; &#63;.
5139            *
5140            * <p>
5141            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5142            * </p>
5143            *
5144            * @param groupId the group ID
5145            * @param userId the user ID
5146            * @param displayDate the display date
5147            * @param status the status
5148            * @param start the lower bound of the range of blogs entries
5149            * @param end the upper bound of the range of blogs entries (not inclusive)
5150            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5151            * @return the ordered range of matching blogs entries that the user has permission to view
5152            * @throws SystemException if a system exception occurred
5153            */
5154            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_LtD_NotS(
5155                    long groupId, long userId, java.util.Date displayDate, int status,
5156                    int start, int end,
5157                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5158                    throws com.liferay.portal.kernel.exception.SystemException {
5159                    return getPersistence()
5160                                       .filterFindByG_U_LtD_NotS(groupId, userId, displayDate,
5161                            status, start, end, orderByComparator);
5162            }
5163    
5164            /**
5165            * 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 &ne; &#63;.
5166            *
5167            * @param entryId the primary key of the current blogs entry
5168            * @param groupId the group ID
5169            * @param userId the user ID
5170            * @param displayDate the display date
5171            * @param status the status
5172            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5173            * @return the previous, current, and next blogs entry
5174            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
5175            * @throws SystemException if a system exception occurred
5176            */
5177            public static com.liferay.portlet.blogs.model.BlogsEntry[] filterFindByG_U_LtD_NotS_PrevAndNext(
5178                    long entryId, long groupId, long userId, java.util.Date displayDate,
5179                    int status,
5180                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5181                    throws com.liferay.portal.kernel.exception.SystemException,
5182                            com.liferay.portlet.blogs.NoSuchEntryException {
5183                    return getPersistence()
5184                                       .filterFindByG_U_LtD_NotS_PrevAndNext(entryId, groupId,
5185                            userId, displayDate, status, orderByComparator);
5186            }
5187    
5188            /**
5189            * Removes all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status &ne; &#63; from the database.
5190            *
5191            * @param groupId the group ID
5192            * @param userId the user ID
5193            * @param displayDate the display date
5194            * @param status the status
5195            * @throws SystemException if a system exception occurred
5196            */
5197            public static void removeByG_U_LtD_NotS(long groupId, long userId,
5198                    java.util.Date displayDate, int status)
5199                    throws com.liferay.portal.kernel.exception.SystemException {
5200                    getPersistence()
5201                            .removeByG_U_LtD_NotS(groupId, userId, displayDate, status);
5202            }
5203    
5204            /**
5205            * Returns the number of blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
5206            *
5207            * @param groupId the group ID
5208            * @param userId the user ID
5209            * @param displayDate the display date
5210            * @param status the status
5211            * @return the number of matching blogs entries
5212            * @throws SystemException if a system exception occurred
5213            */
5214            public static int countByG_U_LtD_NotS(long groupId, long userId,
5215                    java.util.Date displayDate, int status)
5216                    throws com.liferay.portal.kernel.exception.SystemException {
5217                    return getPersistence()
5218                                       .countByG_U_LtD_NotS(groupId, userId, displayDate, status);
5219            }
5220    
5221            /**
5222            * 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 &ne; &#63;.
5223            *
5224            * @param groupId the group ID
5225            * @param userId the user ID
5226            * @param displayDate the display date
5227            * @param status the status
5228            * @return the number of matching blogs entries that the user has permission to view
5229            * @throws SystemException if a system exception occurred
5230            */
5231            public static int filterCountByG_U_LtD_NotS(long groupId, long userId,
5232                    java.util.Date displayDate, int status)
5233                    throws com.liferay.portal.kernel.exception.SystemException {
5234                    return getPersistence()
5235                                       .filterCountByG_U_LtD_NotS(groupId, userId, displayDate,
5236                            status);
5237            }
5238    
5239            /**
5240            * Returns all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
5241            *
5242            * @param groupId the group ID
5243            * @param userId the user ID
5244            * @param displayDate the display date
5245            * @param status the status
5246            * @return the matching blogs entries
5247            * @throws SystemException if a system exception occurred
5248            */
5249            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_LtD_S(
5250                    long groupId, long userId, java.util.Date displayDate, int status)
5251                    throws com.liferay.portal.kernel.exception.SystemException {
5252                    return getPersistence()
5253                                       .findByG_U_LtD_S(groupId, userId, displayDate, status);
5254            }
5255    
5256            /**
5257            * Returns a range of all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
5258            *
5259            * <p>
5260            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5261            * </p>
5262            *
5263            * @param groupId the group ID
5264            * @param userId the user ID
5265            * @param displayDate the display date
5266            * @param status the status
5267            * @param start the lower bound of the range of blogs entries
5268            * @param end the upper bound of the range of blogs entries (not inclusive)
5269            * @return the range of matching blogs entries
5270            * @throws SystemException if a system exception occurred
5271            */
5272            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_LtD_S(
5273                    long groupId, long userId, java.util.Date displayDate, int status,
5274                    int start, int end)
5275                    throws com.liferay.portal.kernel.exception.SystemException {
5276                    return getPersistence()
5277                                       .findByG_U_LtD_S(groupId, userId, displayDate, status,
5278                            start, end);
5279            }
5280    
5281            /**
5282            * Returns an ordered range of all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
5283            *
5284            * <p>
5285            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5286            * </p>
5287            *
5288            * @param groupId the group ID
5289            * @param userId the user ID
5290            * @param displayDate the display date
5291            * @param status the status
5292            * @param start the lower bound of the range of blogs entries
5293            * @param end the upper bound of the range of blogs entries (not inclusive)
5294            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5295            * @return the ordered range of matching blogs entries
5296            * @throws SystemException if a system exception occurred
5297            */
5298            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_LtD_S(
5299                    long groupId, long userId, java.util.Date displayDate, int status,
5300                    int start, int end,
5301                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5302                    throws com.liferay.portal.kernel.exception.SystemException {
5303                    return getPersistence()
5304                                       .findByG_U_LtD_S(groupId, userId, displayDate, status,
5305                            start, end, orderByComparator);
5306            }
5307    
5308            /**
5309            * Returns the first blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
5310            *
5311            * @param groupId the group ID
5312            * @param userId the user ID
5313            * @param displayDate the display date
5314            * @param status the status
5315            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5316            * @return the first matching blogs entry
5317            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
5318            * @throws SystemException if a system exception occurred
5319            */
5320            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_U_LtD_S_First(
5321                    long groupId, long userId, java.util.Date displayDate, int status,
5322                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5323                    throws com.liferay.portal.kernel.exception.SystemException,
5324                            com.liferay.portlet.blogs.NoSuchEntryException {
5325                    return getPersistence()
5326                                       .findByG_U_LtD_S_First(groupId, userId, displayDate, status,
5327                            orderByComparator);
5328            }
5329    
5330            /**
5331            * Returns the first blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
5332            *
5333            * @param groupId the group ID
5334            * @param userId the user ID
5335            * @param displayDate the display date
5336            * @param status the status
5337            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5338            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
5339            * @throws SystemException if a system exception occurred
5340            */
5341            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_U_LtD_S_First(
5342                    long groupId, long userId, java.util.Date displayDate, int status,
5343                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5344                    throws com.liferay.portal.kernel.exception.SystemException {
5345                    return getPersistence()
5346                                       .fetchByG_U_LtD_S_First(groupId, userId, displayDate,
5347                            status, orderByComparator);
5348            }
5349    
5350            /**
5351            * Returns the last blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
5352            *
5353            * @param groupId the group ID
5354            * @param userId the user ID
5355            * @param displayDate the display date
5356            * @param status the status
5357            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5358            * @return the last matching blogs entry
5359            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
5360            * @throws SystemException if a system exception occurred
5361            */
5362            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_U_LtD_S_Last(
5363                    long groupId, long userId, java.util.Date displayDate, int status,
5364                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5365                    throws com.liferay.portal.kernel.exception.SystemException,
5366                            com.liferay.portlet.blogs.NoSuchEntryException {
5367                    return getPersistence()
5368                                       .findByG_U_LtD_S_Last(groupId, userId, displayDate, status,
5369                            orderByComparator);
5370            }
5371    
5372            /**
5373            * Returns the last blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
5374            *
5375            * @param groupId the group ID
5376            * @param userId the user ID
5377            * @param displayDate the display date
5378            * @param status the status
5379            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5380            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
5381            * @throws SystemException if a system exception occurred
5382            */
5383            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_U_LtD_S_Last(
5384                    long groupId, long userId, java.util.Date displayDate, int status,
5385                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5386                    throws com.liferay.portal.kernel.exception.SystemException {
5387                    return getPersistence()
5388                                       .fetchByG_U_LtD_S_Last(groupId, userId, displayDate, status,
5389                            orderByComparator);
5390            }
5391    
5392            /**
5393            * 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;.
5394            *
5395            * @param entryId the primary key of the current blogs entry
5396            * @param groupId the group ID
5397            * @param userId the user ID
5398            * @param displayDate the display date
5399            * @param status the status
5400            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5401            * @return the previous, current, and next blogs entry
5402            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
5403            * @throws SystemException if a system exception occurred
5404            */
5405            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByG_U_LtD_S_PrevAndNext(
5406                    long entryId, long groupId, long userId, java.util.Date displayDate,
5407                    int status,
5408                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5409                    throws com.liferay.portal.kernel.exception.SystemException,
5410                            com.liferay.portlet.blogs.NoSuchEntryException {
5411                    return getPersistence()
5412                                       .findByG_U_LtD_S_PrevAndNext(entryId, groupId, userId,
5413                            displayDate, status, orderByComparator);
5414            }
5415    
5416            /**
5417            * 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;.
5418            *
5419            * @param groupId the group ID
5420            * @param userId the user ID
5421            * @param displayDate the display date
5422            * @param status the status
5423            * @return the matching blogs entries that the user has permission to view
5424            * @throws SystemException if a system exception occurred
5425            */
5426            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_LtD_S(
5427                    long groupId, long userId, java.util.Date displayDate, int status)
5428                    throws com.liferay.portal.kernel.exception.SystemException {
5429                    return getPersistence()
5430                                       .filterFindByG_U_LtD_S(groupId, userId, displayDate, status);
5431            }
5432    
5433            /**
5434            * 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;.
5435            *
5436            * <p>
5437            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5438            * </p>
5439            *
5440            * @param groupId the group ID
5441            * @param userId the user ID
5442            * @param displayDate the display date
5443            * @param status the status
5444            * @param start the lower bound of the range of blogs entries
5445            * @param end the upper bound of the range of blogs entries (not inclusive)
5446            * @return the range of matching blogs entries that the user has permission to view
5447            * @throws SystemException if a system exception occurred
5448            */
5449            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_LtD_S(
5450                    long groupId, long userId, java.util.Date displayDate, int status,
5451                    int start, int end)
5452                    throws com.liferay.portal.kernel.exception.SystemException {
5453                    return getPersistence()
5454                                       .filterFindByG_U_LtD_S(groupId, userId, displayDate, status,
5455                            start, end);
5456            }
5457    
5458            /**
5459            * 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;.
5460            *
5461            * <p>
5462            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5463            * </p>
5464            *
5465            * @param groupId the group ID
5466            * @param userId the user ID
5467            * @param displayDate the display date
5468            * @param status the status
5469            * @param start the lower bound of the range of blogs entries
5470            * @param end the upper bound of the range of blogs entries (not inclusive)
5471            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5472            * @return the ordered range of matching blogs entries that the user has permission to view
5473            * @throws SystemException if a system exception occurred
5474            */
5475            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_LtD_S(
5476                    long groupId, long userId, java.util.Date displayDate, int status,
5477                    int start, int end,
5478                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5479                    throws com.liferay.portal.kernel.exception.SystemException {
5480                    return getPersistence()
5481                                       .filterFindByG_U_LtD_S(groupId, userId, displayDate, status,
5482                            start, end, orderByComparator);
5483            }
5484    
5485            /**
5486            * 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;.
5487            *
5488            * @param entryId the primary key of the current blogs entry
5489            * @param groupId the group ID
5490            * @param userId the user ID
5491            * @param displayDate the display date
5492            * @param status the status
5493            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
5494            * @return the previous, current, and next blogs entry
5495            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
5496            * @throws SystemException if a system exception occurred
5497            */
5498            public static com.liferay.portlet.blogs.model.BlogsEntry[] filterFindByG_U_LtD_S_PrevAndNext(
5499                    long entryId, long groupId, long userId, java.util.Date displayDate,
5500                    int status,
5501                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5502                    throws com.liferay.portal.kernel.exception.SystemException,
5503                            com.liferay.portlet.blogs.NoSuchEntryException {
5504                    return getPersistence()
5505                                       .filterFindByG_U_LtD_S_PrevAndNext(entryId, groupId, userId,
5506                            displayDate, status, orderByComparator);
5507            }
5508    
5509            /**
5510            * Removes all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63; from the database.
5511            *
5512            * @param groupId the group ID
5513            * @param userId the user ID
5514            * @param displayDate the display date
5515            * @param status the status
5516            * @throws SystemException if a system exception occurred
5517            */
5518            public static void removeByG_U_LtD_S(long groupId, long userId,
5519                    java.util.Date displayDate, int status)
5520                    throws com.liferay.portal.kernel.exception.SystemException {
5521                    getPersistence().removeByG_U_LtD_S(groupId, userId, displayDate, status);
5522            }
5523    
5524            /**
5525            * Returns the number of blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
5526            *
5527            * @param groupId the group ID
5528            * @param userId the user ID
5529            * @param displayDate the display date
5530            * @param status the status
5531            * @return the number of matching blogs entries
5532            * @throws SystemException if a system exception occurred
5533            */
5534            public static int countByG_U_LtD_S(long groupId, long userId,
5535                    java.util.Date displayDate, int status)
5536                    throws com.liferay.portal.kernel.exception.SystemException {
5537                    return getPersistence()
5538                                       .countByG_U_LtD_S(groupId, userId, displayDate, status);
5539            }
5540    
5541            /**
5542            * 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;.
5543            *
5544            * @param groupId the group ID
5545            * @param userId the user ID
5546            * @param displayDate the display date
5547            * @param status the status
5548            * @return the number of matching blogs entries that the user has permission to view
5549            * @throws SystemException if a system exception occurred
5550            */
5551            public static int filterCountByG_U_LtD_S(long groupId, long userId,
5552                    java.util.Date displayDate, int status)
5553                    throws com.liferay.portal.kernel.exception.SystemException {
5554                    return getPersistence()
5555                                       .filterCountByG_U_LtD_S(groupId, userId, displayDate, status);
5556            }
5557    
5558            /**
5559            * Caches the blogs entry in the entity cache if it is enabled.
5560            *
5561            * @param blogsEntry the blogs entry
5562            */
5563            public static void cacheResult(
5564                    com.liferay.portlet.blogs.model.BlogsEntry blogsEntry) {
5565                    getPersistence().cacheResult(blogsEntry);
5566            }
5567    
5568            /**
5569            * Caches the blogs entries in the entity cache if it is enabled.
5570            *
5571            * @param blogsEntries the blogs entries
5572            */
5573            public static void cacheResult(
5574                    java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> blogsEntries) {
5575                    getPersistence().cacheResult(blogsEntries);
5576            }
5577    
5578            /**
5579            * Creates a new blogs entry with the primary key. Does not add the blogs entry to the database.
5580            *
5581            * @param entryId the primary key for the new blogs entry
5582            * @return the new blogs entry
5583            */
5584            public static com.liferay.portlet.blogs.model.BlogsEntry create(
5585                    long entryId) {
5586                    return getPersistence().create(entryId);
5587            }
5588    
5589            /**
5590            * Removes the blogs entry with the primary key from the database. Also notifies the appropriate model listeners.
5591            *
5592            * @param entryId the primary key of the blogs entry
5593            * @return the blogs entry that was removed
5594            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
5595            * @throws SystemException if a system exception occurred
5596            */
5597            public static com.liferay.portlet.blogs.model.BlogsEntry remove(
5598                    long entryId)
5599                    throws com.liferay.portal.kernel.exception.SystemException,
5600                            com.liferay.portlet.blogs.NoSuchEntryException {
5601                    return getPersistence().remove(entryId);
5602            }
5603    
5604            public static com.liferay.portlet.blogs.model.BlogsEntry updateImpl(
5605                    com.liferay.portlet.blogs.model.BlogsEntry blogsEntry)
5606                    throws com.liferay.portal.kernel.exception.SystemException {
5607                    return getPersistence().updateImpl(blogsEntry);
5608            }
5609    
5610            /**
5611            * Returns the blogs entry with the primary key or throws a {@link com.liferay.portlet.blogs.NoSuchEntryException} if it could not be found.
5612            *
5613            * @param entryId the primary key of the blogs entry
5614            * @return the blogs entry
5615            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
5616            * @throws SystemException if a system exception occurred
5617            */
5618            public static com.liferay.portlet.blogs.model.BlogsEntry findByPrimaryKey(
5619                    long entryId)
5620                    throws com.liferay.portal.kernel.exception.SystemException,
5621                            com.liferay.portlet.blogs.NoSuchEntryException {
5622                    return getPersistence().findByPrimaryKey(entryId);
5623            }
5624    
5625            /**
5626            * Returns the blogs entry with the primary key or returns <code>null</code> if it could not be found.
5627            *
5628            * @param entryId the primary key of the blogs entry
5629            * @return the blogs entry, or <code>null</code> if a blogs entry with the primary key could not be found
5630            * @throws SystemException if a system exception occurred
5631            */
5632            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByPrimaryKey(
5633                    long entryId)
5634                    throws com.liferay.portal.kernel.exception.SystemException {
5635                    return getPersistence().fetchByPrimaryKey(entryId);
5636            }
5637    
5638            /**
5639            * Returns all the blogs entries.
5640            *
5641            * @return the blogs entries
5642            * @throws SystemException if a system exception occurred
5643            */
5644            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findAll()
5645                    throws com.liferay.portal.kernel.exception.SystemException {
5646                    return getPersistence().findAll();
5647            }
5648    
5649            /**
5650            * Returns a range of all the blogs entries.
5651            *
5652            * <p>
5653            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5654            * </p>
5655            *
5656            * @param start the lower bound of the range of blogs entries
5657            * @param end the upper bound of the range of blogs entries (not inclusive)
5658            * @return the range of blogs entries
5659            * @throws SystemException if a system exception occurred
5660            */
5661            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findAll(
5662                    int start, int end)
5663                    throws com.liferay.portal.kernel.exception.SystemException {
5664                    return getPersistence().findAll(start, end);
5665            }
5666    
5667            /**
5668            * Returns an ordered range of all the blogs entries.
5669            *
5670            * <p>
5671            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
5672            * </p>
5673            *
5674            * @param start the lower bound of the range of blogs entries
5675            * @param end the upper bound of the range of blogs entries (not inclusive)
5676            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
5677            * @return the ordered range of blogs entries
5678            * @throws SystemException if a system exception occurred
5679            */
5680            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findAll(
5681                    int start, int end,
5682                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
5683                    throws com.liferay.portal.kernel.exception.SystemException {
5684                    return getPersistence().findAll(start, end, orderByComparator);
5685            }
5686    
5687            /**
5688            * Removes all the blogs entries from the database.
5689            *
5690            * @throws SystemException if a system exception occurred
5691            */
5692            public static void removeAll()
5693                    throws com.liferay.portal.kernel.exception.SystemException {
5694                    getPersistence().removeAll();
5695            }
5696    
5697            /**
5698            * Returns the number of blogs entries.
5699            *
5700            * @return the number of blogs entries
5701            * @throws SystemException if a system exception occurred
5702            */
5703            public static int countAll()
5704                    throws com.liferay.portal.kernel.exception.SystemException {
5705                    return getPersistence().countAll();
5706            }
5707    
5708            public static BlogsEntryPersistence getPersistence() {
5709                    if (_persistence == null) {
5710                            _persistence = (BlogsEntryPersistence)PortalBeanLocatorUtil.locate(BlogsEntryPersistence.class.getName());
5711    
5712                            ReferenceRegistry.registerReference(BlogsEntryUtil.class,
5713                                    "_persistence");
5714                    }
5715    
5716                    return _persistence;
5717            }
5718    
5719            /**
5720             * @deprecated As of 6.2.0
5721             */
5722            public void setPersistence(BlogsEntryPersistence persistence) {
5723            }
5724    
5725            private static BlogsEntryPersistence _persistence;
5726    }