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