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