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