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