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