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