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