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.BlogsStatsUser;
022    
023    /**
024     * The persistence interface for the blogs stats user 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.BlogsStatsUserPersistenceImpl
032     * @see BlogsStatsUserUtil
033     * @generated
034     */
035    @ProviderType
036    public interface BlogsStatsUserPersistence extends BasePersistence<BlogsStatsUser> {
037            /*
038             * NOTE FOR DEVELOPERS:
039             *
040             * Never modify or reference this interface directly. Always use {@link BlogsStatsUserUtil} to access the blogs stats user persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface.
041             */
042    
043            /**
044            * Returns all the blogs stats users where groupId = &#63;.
045            *
046            * @param groupId the group ID
047            * @return the matching blogs stats users
048            */
049            public java.util.List<BlogsStatsUser> findByGroupId(long groupId);
050    
051            /**
052            * Returns a range of all the blogs stats users where groupId = &#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 BlogsStatsUserModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query 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 groupId the group ID
059            * @param start the lower bound of the range of blogs stats users
060            * @param end the upper bound of the range of blogs stats users (not inclusive)
061            * @return the range of matching blogs stats users
062            */
063            public java.util.List<BlogsStatsUser> findByGroupId(long groupId,
064                    int start, int end);
065    
066            /**
067            * Returns an ordered range of all the blogs stats users where groupId = &#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 BlogsStatsUserModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query 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 groupId the group ID
074            * @param start the lower bound of the range of blogs stats users
075            * @param end the upper bound of the range of blogs stats users (not inclusive)
076            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
077            * @return the ordered range of matching blogs stats users
078            */
079            public java.util.List<BlogsStatsUser> findByGroupId(long groupId,
080                    int start, int end,
081                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator);
082    
083            /**
084            * Returns an ordered range of all the blogs stats users where groupId = &#63;.
085            *
086            * <p>
087            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsStatsUserModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
088            * </p>
089            *
090            * @param groupId the group ID
091            * @param start the lower bound of the range of blogs stats users
092            * @param end the upper bound of the range of blogs stats users (not inclusive)
093            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
094            * @param retrieveFromCache whether to retrieve from the finder cache
095            * @return the ordered range of matching blogs stats users
096            */
097            public java.util.List<BlogsStatsUser> findByGroupId(long groupId,
098                    int start, int end,
099                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator,
100                    boolean retrieveFromCache);
101    
102            /**
103            * Returns the first blogs stats user in the ordered set where groupId = &#63;.
104            *
105            * @param groupId the group ID
106            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
107            * @return the first matching blogs stats user
108            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
109            */
110            public BlogsStatsUser findByGroupId_First(long groupId,
111                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator)
112                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException;
113    
114            /**
115            * Returns the first blogs stats user in the ordered set where groupId = &#63;.
116            *
117            * @param groupId the group ID
118            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
119            * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
120            */
121            public BlogsStatsUser fetchByGroupId_First(long groupId,
122                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator);
123    
124            /**
125            * Returns the last blogs stats user in the ordered set where groupId = &#63;.
126            *
127            * @param groupId the group ID
128            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
129            * @return the last matching blogs stats user
130            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
131            */
132            public BlogsStatsUser findByGroupId_Last(long groupId,
133                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator)
134                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException;
135    
136            /**
137            * Returns the last blogs stats user in the ordered set where groupId = &#63;.
138            *
139            * @param groupId the group ID
140            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
141            * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
142            */
143            public BlogsStatsUser fetchByGroupId_Last(long groupId,
144                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator);
145    
146            /**
147            * Returns the blogs stats users before and after the current blogs stats user in the ordered set where groupId = &#63;.
148            *
149            * @param statsUserId the primary key of the current blogs stats user
150            * @param groupId the group ID
151            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
152            * @return the previous, current, and next blogs stats user
153            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
154            */
155            public BlogsStatsUser[] findByGroupId_PrevAndNext(long statsUserId,
156                    long groupId,
157                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator)
158                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException;
159    
160            /**
161            * Removes all the blogs stats users where groupId = &#63; from the database.
162            *
163            * @param groupId the group ID
164            */
165            public void removeByGroupId(long groupId);
166    
167            /**
168            * Returns the number of blogs stats users where groupId = &#63;.
169            *
170            * @param groupId the group ID
171            * @return the number of matching blogs stats users
172            */
173            public int countByGroupId(long groupId);
174    
175            /**
176            * Returns all the blogs stats users where userId = &#63;.
177            *
178            * @param userId the user ID
179            * @return the matching blogs stats users
180            */
181            public java.util.List<BlogsStatsUser> findByUserId(long userId);
182    
183            /**
184            * Returns a range of all the blogs stats users where userId = &#63;.
185            *
186            * <p>
187            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsStatsUserModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
188            * </p>
189            *
190            * @param userId the user ID
191            * @param start the lower bound of the range of blogs stats users
192            * @param end the upper bound of the range of blogs stats users (not inclusive)
193            * @return the range of matching blogs stats users
194            */
195            public java.util.List<BlogsStatsUser> findByUserId(long userId, int start,
196                    int end);
197    
198            /**
199            * Returns an ordered range of all the blogs stats users where userId = &#63;.
200            *
201            * <p>
202            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsStatsUserModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
203            * </p>
204            *
205            * @param userId the user ID
206            * @param start the lower bound of the range of blogs stats users
207            * @param end the upper bound of the range of blogs stats users (not inclusive)
208            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
209            * @return the ordered range of matching blogs stats users
210            */
211            public java.util.List<BlogsStatsUser> findByUserId(long userId, int start,
212                    int end,
213                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator);
214    
215            /**
216            * Returns an ordered range of all the blogs stats users where userId = &#63;.
217            *
218            * <p>
219            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsStatsUserModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
220            * </p>
221            *
222            * @param userId the user ID
223            * @param start the lower bound of the range of blogs stats users
224            * @param end the upper bound of the range of blogs stats users (not inclusive)
225            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
226            * @param retrieveFromCache whether to retrieve from the finder cache
227            * @return the ordered range of matching blogs stats users
228            */
229            public java.util.List<BlogsStatsUser> findByUserId(long userId, int start,
230                    int end,
231                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator,
232                    boolean retrieveFromCache);
233    
234            /**
235            * Returns the first blogs stats user in the ordered set where userId = &#63;.
236            *
237            * @param userId the user ID
238            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
239            * @return the first matching blogs stats user
240            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
241            */
242            public BlogsStatsUser findByUserId_First(long userId,
243                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator)
244                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException;
245    
246            /**
247            * Returns the first blogs stats user in the ordered set where userId = &#63;.
248            *
249            * @param userId the user ID
250            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
251            * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
252            */
253            public BlogsStatsUser fetchByUserId_First(long userId,
254                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator);
255    
256            /**
257            * Returns the last blogs stats user in the ordered set where userId = &#63;.
258            *
259            * @param userId the user ID
260            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
261            * @return the last matching blogs stats user
262            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
263            */
264            public BlogsStatsUser findByUserId_Last(long userId,
265                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator)
266                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException;
267    
268            /**
269            * Returns the last blogs stats user in the ordered set where userId = &#63;.
270            *
271            * @param userId the user ID
272            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
273            * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
274            */
275            public BlogsStatsUser fetchByUserId_Last(long userId,
276                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator);
277    
278            /**
279            * Returns the blogs stats users before and after the current blogs stats user in the ordered set where userId = &#63;.
280            *
281            * @param statsUserId the primary key of the current blogs stats user
282            * @param userId the user ID
283            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
284            * @return the previous, current, and next blogs stats user
285            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
286            */
287            public BlogsStatsUser[] findByUserId_PrevAndNext(long statsUserId,
288                    long userId,
289                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator)
290                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException;
291    
292            /**
293            * Removes all the blogs stats users where userId = &#63; from the database.
294            *
295            * @param userId the user ID
296            */
297            public void removeByUserId(long userId);
298    
299            /**
300            * Returns the number of blogs stats users where userId = &#63;.
301            *
302            * @param userId the user ID
303            * @return the number of matching blogs stats users
304            */
305            public int countByUserId(long userId);
306    
307            /**
308            * Returns the blogs stats user where groupId = &#63; and userId = &#63; or throws a {@link NoSuchStatsUserException} if it could not be found.
309            *
310            * @param groupId the group ID
311            * @param userId the user ID
312            * @return the matching blogs stats user
313            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
314            */
315            public BlogsStatsUser findByG_U(long groupId, long userId)
316                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException;
317    
318            /**
319            * Returns the blogs stats user where groupId = &#63; and userId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
320            *
321            * @param groupId the group ID
322            * @param userId the user ID
323            * @return the matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
324            */
325            public BlogsStatsUser fetchByG_U(long groupId, long userId);
326    
327            /**
328            * Returns the blogs stats user where groupId = &#63; and userId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
329            *
330            * @param groupId the group ID
331            * @param userId the user ID
332            * @param retrieveFromCache whether to retrieve from the finder cache
333            * @return the matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
334            */
335            public BlogsStatsUser fetchByG_U(long groupId, long userId,
336                    boolean retrieveFromCache);
337    
338            /**
339            * Removes the blogs stats user where groupId = &#63; and userId = &#63; from the database.
340            *
341            * @param groupId the group ID
342            * @param userId the user ID
343            * @return the blogs stats user that was removed
344            */
345            public BlogsStatsUser removeByG_U(long groupId, long userId)
346                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException;
347    
348            /**
349            * Returns the number of blogs stats users where groupId = &#63; and userId = &#63;.
350            *
351            * @param groupId the group ID
352            * @param userId the user ID
353            * @return the number of matching blogs stats users
354            */
355            public int countByG_U(long groupId, long userId);
356    
357            /**
358            * Returns all the blogs stats users where groupId = &#63; and entryCount &ne; &#63;.
359            *
360            * @param groupId the group ID
361            * @param entryCount the entry count
362            * @return the matching blogs stats users
363            */
364            public java.util.List<BlogsStatsUser> findByG_NotE(long groupId,
365                    int entryCount);
366    
367            /**
368            * Returns a range of all the blogs stats users where groupId = &#63; and entryCount &ne; &#63;.
369            *
370            * <p>
371            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsStatsUserModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
372            * </p>
373            *
374            * @param groupId the group ID
375            * @param entryCount the entry count
376            * @param start the lower bound of the range of blogs stats users
377            * @param end the upper bound of the range of blogs stats users (not inclusive)
378            * @return the range of matching blogs stats users
379            */
380            public java.util.List<BlogsStatsUser> findByG_NotE(long groupId,
381                    int entryCount, int start, int end);
382    
383            /**
384            * Returns an ordered range of all the blogs stats users where groupId = &#63; and entryCount &ne; &#63;.
385            *
386            * <p>
387            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsStatsUserModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
388            * </p>
389            *
390            * @param groupId the group ID
391            * @param entryCount the entry count
392            * @param start the lower bound of the range of blogs stats users
393            * @param end the upper bound of the range of blogs stats users (not inclusive)
394            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
395            * @return the ordered range of matching blogs stats users
396            */
397            public java.util.List<BlogsStatsUser> findByG_NotE(long groupId,
398                    int entryCount, int start, int end,
399                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator);
400    
401            /**
402            * Returns an ordered range of all the blogs stats users where groupId = &#63; and entryCount &ne; &#63;.
403            *
404            * <p>
405            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsStatsUserModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
406            * </p>
407            *
408            * @param groupId the group ID
409            * @param entryCount the entry count
410            * @param start the lower bound of the range of blogs stats users
411            * @param end the upper bound of the range of blogs stats users (not inclusive)
412            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
413            * @param retrieveFromCache whether to retrieve from the finder cache
414            * @return the ordered range of matching blogs stats users
415            */
416            public java.util.List<BlogsStatsUser> findByG_NotE(long groupId,
417                    int entryCount, int start, int end,
418                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator,
419                    boolean retrieveFromCache);
420    
421            /**
422            * Returns the first blogs stats user in the ordered set where groupId = &#63; and entryCount &ne; &#63;.
423            *
424            * @param groupId the group ID
425            * @param entryCount the entry count
426            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
427            * @return the first matching blogs stats user
428            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
429            */
430            public BlogsStatsUser findByG_NotE_First(long groupId, int entryCount,
431                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator)
432                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException;
433    
434            /**
435            * Returns the first blogs stats user in the ordered set where groupId = &#63; and entryCount &ne; &#63;.
436            *
437            * @param groupId the group ID
438            * @param entryCount the entry count
439            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
440            * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
441            */
442            public BlogsStatsUser fetchByG_NotE_First(long groupId, int entryCount,
443                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator);
444    
445            /**
446            * Returns the last blogs stats user in the ordered set where groupId = &#63; and entryCount &ne; &#63;.
447            *
448            * @param groupId the group ID
449            * @param entryCount the entry count
450            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
451            * @return the last matching blogs stats user
452            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
453            */
454            public BlogsStatsUser findByG_NotE_Last(long groupId, int entryCount,
455                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator)
456                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException;
457    
458            /**
459            * Returns the last blogs stats user in the ordered set where groupId = &#63; and entryCount &ne; &#63;.
460            *
461            * @param groupId the group ID
462            * @param entryCount the entry count
463            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
464            * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
465            */
466            public BlogsStatsUser fetchByG_NotE_Last(long groupId, int entryCount,
467                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator);
468    
469            /**
470            * Returns the blogs stats users before and after the current blogs stats user in the ordered set where groupId = &#63; and entryCount &ne; &#63;.
471            *
472            * @param statsUserId the primary key of the current blogs stats user
473            * @param groupId the group ID
474            * @param entryCount the entry count
475            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
476            * @return the previous, current, and next blogs stats user
477            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
478            */
479            public BlogsStatsUser[] findByG_NotE_PrevAndNext(long statsUserId,
480                    long groupId, int entryCount,
481                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator)
482                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException;
483    
484            /**
485            * Removes all the blogs stats users where groupId = &#63; and entryCount &ne; &#63; from the database.
486            *
487            * @param groupId the group ID
488            * @param entryCount the entry count
489            */
490            public void removeByG_NotE(long groupId, int entryCount);
491    
492            /**
493            * Returns the number of blogs stats users where groupId = &#63; and entryCount &ne; &#63;.
494            *
495            * @param groupId the group ID
496            * @param entryCount the entry count
497            * @return the number of matching blogs stats users
498            */
499            public int countByG_NotE(long groupId, int entryCount);
500    
501            /**
502            * Returns all the blogs stats users where companyId = &#63; and entryCount &ne; &#63;.
503            *
504            * @param companyId the company ID
505            * @param entryCount the entry count
506            * @return the matching blogs stats users
507            */
508            public java.util.List<BlogsStatsUser> findByC_NotE(long companyId,
509                    int entryCount);
510    
511            /**
512            * Returns a range of all the blogs stats users where companyId = &#63; and entryCount &ne; &#63;.
513            *
514            * <p>
515            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsStatsUserModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
516            * </p>
517            *
518            * @param companyId the company ID
519            * @param entryCount the entry count
520            * @param start the lower bound of the range of blogs stats users
521            * @param end the upper bound of the range of blogs stats users (not inclusive)
522            * @return the range of matching blogs stats users
523            */
524            public java.util.List<BlogsStatsUser> findByC_NotE(long companyId,
525                    int entryCount, int start, int end);
526    
527            /**
528            * Returns an ordered range of all the blogs stats users where companyId = &#63; and entryCount &ne; &#63;.
529            *
530            * <p>
531            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsStatsUserModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
532            * </p>
533            *
534            * @param companyId the company ID
535            * @param entryCount the entry count
536            * @param start the lower bound of the range of blogs stats users
537            * @param end the upper bound of the range of blogs stats users (not inclusive)
538            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
539            * @return the ordered range of matching blogs stats users
540            */
541            public java.util.List<BlogsStatsUser> findByC_NotE(long companyId,
542                    int entryCount, int start, int end,
543                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator);
544    
545            /**
546            * Returns an ordered range of all the blogs stats users where companyId = &#63; and entryCount &ne; &#63;.
547            *
548            * <p>
549            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsStatsUserModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
550            * </p>
551            *
552            * @param companyId the company ID
553            * @param entryCount the entry count
554            * @param start the lower bound of the range of blogs stats users
555            * @param end the upper bound of the range of blogs stats users (not inclusive)
556            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
557            * @param retrieveFromCache whether to retrieve from the finder cache
558            * @return the ordered range of matching blogs stats users
559            */
560            public java.util.List<BlogsStatsUser> findByC_NotE(long companyId,
561                    int entryCount, int start, int end,
562                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator,
563                    boolean retrieveFromCache);
564    
565            /**
566            * Returns the first blogs stats user in the ordered set where companyId = &#63; and entryCount &ne; &#63;.
567            *
568            * @param companyId the company ID
569            * @param entryCount the entry count
570            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
571            * @return the first matching blogs stats user
572            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
573            */
574            public BlogsStatsUser findByC_NotE_First(long companyId, int entryCount,
575                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator)
576                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException;
577    
578            /**
579            * Returns the first blogs stats user in the ordered set where companyId = &#63; and entryCount &ne; &#63;.
580            *
581            * @param companyId the company ID
582            * @param entryCount the entry count
583            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
584            * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
585            */
586            public BlogsStatsUser fetchByC_NotE_First(long companyId, int entryCount,
587                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator);
588    
589            /**
590            * Returns the last blogs stats user in the ordered set where companyId = &#63; and entryCount &ne; &#63;.
591            *
592            * @param companyId the company ID
593            * @param entryCount the entry count
594            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
595            * @return the last matching blogs stats user
596            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
597            */
598            public BlogsStatsUser findByC_NotE_Last(long companyId, int entryCount,
599                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator)
600                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException;
601    
602            /**
603            * Returns the last blogs stats user in the ordered set where companyId = &#63; and entryCount &ne; &#63;.
604            *
605            * @param companyId the company ID
606            * @param entryCount the entry count
607            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
608            * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
609            */
610            public BlogsStatsUser fetchByC_NotE_Last(long companyId, int entryCount,
611                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator);
612    
613            /**
614            * Returns the blogs stats users before and after the current blogs stats user in the ordered set where companyId = &#63; and entryCount &ne; &#63;.
615            *
616            * @param statsUserId the primary key of the current blogs stats user
617            * @param companyId the company ID
618            * @param entryCount the entry count
619            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
620            * @return the previous, current, and next blogs stats user
621            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
622            */
623            public BlogsStatsUser[] findByC_NotE_PrevAndNext(long statsUserId,
624                    long companyId, int entryCount,
625                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator)
626                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException;
627    
628            /**
629            * Removes all the blogs stats users where companyId = &#63; and entryCount &ne; &#63; from the database.
630            *
631            * @param companyId the company ID
632            * @param entryCount the entry count
633            */
634            public void removeByC_NotE(long companyId, int entryCount);
635    
636            /**
637            * Returns the number of blogs stats users where companyId = &#63; and entryCount &ne; &#63;.
638            *
639            * @param companyId the company ID
640            * @param entryCount the entry count
641            * @return the number of matching blogs stats users
642            */
643            public int countByC_NotE(long companyId, int entryCount);
644    
645            /**
646            * Returns all the blogs stats users where userId = &#63; and lastPostDate = &#63;.
647            *
648            * @param userId the user ID
649            * @param lastPostDate the last post date
650            * @return the matching blogs stats users
651            */
652            public java.util.List<BlogsStatsUser> findByU_L(long userId,
653                    java.util.Date lastPostDate);
654    
655            /**
656            * Returns a range of all the blogs stats users where userId = &#63; and lastPostDate = &#63;.
657            *
658            * <p>
659            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsStatsUserModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
660            * </p>
661            *
662            * @param userId the user ID
663            * @param lastPostDate the last post date
664            * @param start the lower bound of the range of blogs stats users
665            * @param end the upper bound of the range of blogs stats users (not inclusive)
666            * @return the range of matching blogs stats users
667            */
668            public java.util.List<BlogsStatsUser> findByU_L(long userId,
669                    java.util.Date lastPostDate, int start, int end);
670    
671            /**
672            * Returns an ordered range of all the blogs stats users where userId = &#63; and lastPostDate = &#63;.
673            *
674            * <p>
675            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsStatsUserModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
676            * </p>
677            *
678            * @param userId the user ID
679            * @param lastPostDate the last post date
680            * @param start the lower bound of the range of blogs stats users
681            * @param end the upper bound of the range of blogs stats users (not inclusive)
682            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
683            * @return the ordered range of matching blogs stats users
684            */
685            public java.util.List<BlogsStatsUser> findByU_L(long userId,
686                    java.util.Date lastPostDate, int start, int end,
687                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator);
688    
689            /**
690            * Returns an ordered range of all the blogs stats users where userId = &#63; and lastPostDate = &#63;.
691            *
692            * <p>
693            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsStatsUserModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
694            * </p>
695            *
696            * @param userId the user ID
697            * @param lastPostDate the last post date
698            * @param start the lower bound of the range of blogs stats users
699            * @param end the upper bound of the range of blogs stats users (not inclusive)
700            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
701            * @param retrieveFromCache whether to retrieve from the finder cache
702            * @return the ordered range of matching blogs stats users
703            */
704            public java.util.List<BlogsStatsUser> findByU_L(long userId,
705                    java.util.Date lastPostDate, int start, int end,
706                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator,
707                    boolean retrieveFromCache);
708    
709            /**
710            * Returns the first blogs stats user in the ordered set where userId = &#63; and lastPostDate = &#63;.
711            *
712            * @param userId the user ID
713            * @param lastPostDate the last post date
714            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
715            * @return the first matching blogs stats user
716            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
717            */
718            public BlogsStatsUser findByU_L_First(long userId,
719                    java.util.Date lastPostDate,
720                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator)
721                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException;
722    
723            /**
724            * Returns the first blogs stats user in the ordered set where userId = &#63; and lastPostDate = &#63;.
725            *
726            * @param userId the user ID
727            * @param lastPostDate the last post date
728            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
729            * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
730            */
731            public BlogsStatsUser fetchByU_L_First(long userId,
732                    java.util.Date lastPostDate,
733                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator);
734    
735            /**
736            * Returns the last blogs stats user in the ordered set where userId = &#63; and lastPostDate = &#63;.
737            *
738            * @param userId the user ID
739            * @param lastPostDate the last post date
740            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
741            * @return the last matching blogs stats user
742            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
743            */
744            public BlogsStatsUser findByU_L_Last(long userId,
745                    java.util.Date lastPostDate,
746                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator)
747                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException;
748    
749            /**
750            * Returns the last blogs stats user in the ordered set where userId = &#63; and lastPostDate = &#63;.
751            *
752            * @param userId the user ID
753            * @param lastPostDate the last post date
754            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
755            * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
756            */
757            public BlogsStatsUser fetchByU_L_Last(long userId,
758                    java.util.Date lastPostDate,
759                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator);
760    
761            /**
762            * Returns the blogs stats users before and after the current blogs stats user in the ordered set where userId = &#63; and lastPostDate = &#63;.
763            *
764            * @param statsUserId the primary key of the current blogs stats user
765            * @param userId the user ID
766            * @param lastPostDate the last post date
767            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
768            * @return the previous, current, and next blogs stats user
769            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
770            */
771            public BlogsStatsUser[] findByU_L_PrevAndNext(long statsUserId,
772                    long userId, java.util.Date lastPostDate,
773                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator)
774                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException;
775    
776            /**
777            * Removes all the blogs stats users where userId = &#63; and lastPostDate = &#63; from the database.
778            *
779            * @param userId the user ID
780            * @param lastPostDate the last post date
781            */
782            public void removeByU_L(long userId, java.util.Date lastPostDate);
783    
784            /**
785            * Returns the number of blogs stats users where userId = &#63; and lastPostDate = &#63;.
786            *
787            * @param userId the user ID
788            * @param lastPostDate the last post date
789            * @return the number of matching blogs stats users
790            */
791            public int countByU_L(long userId, java.util.Date lastPostDate);
792    
793            /**
794            * Caches the blogs stats user in the entity cache if it is enabled.
795            *
796            * @param blogsStatsUser the blogs stats user
797            */
798            public void cacheResult(BlogsStatsUser blogsStatsUser);
799    
800            /**
801            * Caches the blogs stats users in the entity cache if it is enabled.
802            *
803            * @param blogsStatsUsers the blogs stats users
804            */
805            public void cacheResult(java.util.List<BlogsStatsUser> blogsStatsUsers);
806    
807            /**
808            * Creates a new blogs stats user with the primary key. Does not add the blogs stats user to the database.
809            *
810            * @param statsUserId the primary key for the new blogs stats user
811            * @return the new blogs stats user
812            */
813            public BlogsStatsUser create(long statsUserId);
814    
815            /**
816            * Removes the blogs stats user with the primary key from the database. Also notifies the appropriate model listeners.
817            *
818            * @param statsUserId the primary key of the blogs stats user
819            * @return the blogs stats user that was removed
820            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
821            */
822            public BlogsStatsUser remove(long statsUserId)
823                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException;
824    
825            public BlogsStatsUser updateImpl(BlogsStatsUser blogsStatsUser);
826    
827            /**
828            * Returns the blogs stats user with the primary key or throws a {@link NoSuchStatsUserException} if it could not be found.
829            *
830            * @param statsUserId the primary key of the blogs stats user
831            * @return the blogs stats user
832            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
833            */
834            public BlogsStatsUser findByPrimaryKey(long statsUserId)
835                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException;
836    
837            /**
838            * Returns the blogs stats user with the primary key or returns <code>null</code> if it could not be found.
839            *
840            * @param statsUserId the primary key of the blogs stats user
841            * @return the blogs stats user, or <code>null</code> if a blogs stats user with the primary key could not be found
842            */
843            public BlogsStatsUser fetchByPrimaryKey(long statsUserId);
844    
845            @Override
846            public java.util.Map<java.io.Serializable, BlogsStatsUser> fetchByPrimaryKeys(
847                    java.util.Set<java.io.Serializable> primaryKeys);
848    
849            /**
850            * Returns all the blogs stats users.
851            *
852            * @return the blogs stats users
853            */
854            public java.util.List<BlogsStatsUser> findAll();
855    
856            /**
857            * Returns a range of all the blogs stats users.
858            *
859            * <p>
860            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsStatsUserModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
861            * </p>
862            *
863            * @param start the lower bound of the range of blogs stats users
864            * @param end the upper bound of the range of blogs stats users (not inclusive)
865            * @return the range of blogs stats users
866            */
867            public java.util.List<BlogsStatsUser> findAll(int start, int end);
868    
869            /**
870            * Returns an ordered range of all the blogs stats users.
871            *
872            * <p>
873            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsStatsUserModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
874            * </p>
875            *
876            * @param start the lower bound of the range of blogs stats users
877            * @param end the upper bound of the range of blogs stats users (not inclusive)
878            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
879            * @return the ordered range of blogs stats users
880            */
881            public java.util.List<BlogsStatsUser> findAll(int start, int end,
882                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator);
883    
884            /**
885            * Returns an ordered range of all the blogs stats users.
886            *
887            * <p>
888            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsStatsUserModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
889            * </p>
890            *
891            * @param start the lower bound of the range of blogs stats users
892            * @param end the upper bound of the range of blogs stats users (not inclusive)
893            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
894            * @param retrieveFromCache whether to retrieve from the finder cache
895            * @return the ordered range of blogs stats users
896            */
897            public java.util.List<BlogsStatsUser> findAll(int start, int end,
898                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator,
899                    boolean retrieveFromCache);
900    
901            /**
902            * Removes all the blogs stats users from the database.
903            */
904            public void removeAll();
905    
906            /**
907            * Returns the number of blogs stats users.
908            *
909            * @return the number of blogs stats users
910            */
911            public int countAll();
912    }