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