001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.blogs.service.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
020    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
021    import com.liferay.portal.kernel.util.OrderByComparator;
022    import com.liferay.portal.kernel.util.ReferenceRegistry;
023    import com.liferay.portal.service.ServiceContext;
024    
025    import com.liferay.portlet.blogs.model.BlogsStatsUser;
026    
027    import java.util.List;
028    
029    /**
030     * The persistence utility for the blogs stats user service. This utility wraps {@link com.liferay.portlet.blogs.service.persistence.impl.BlogsStatsUserPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
031     *
032     * <p>
033     * Caching information and settings can be found in <code>portal.properties</code>
034     * </p>
035     *
036     * @author Brian Wing Shun Chan
037     * @see BlogsStatsUserPersistence
038     * @see com.liferay.portlet.blogs.service.persistence.impl.BlogsStatsUserPersistenceImpl
039     * @generated
040     */
041    @ProviderType
042    public class BlogsStatsUserUtil {
043            /*
044             * NOTE FOR DEVELOPERS:
045             *
046             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
047             */
048    
049            /**
050             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
051             */
052            public static void clearCache() {
053                    getPersistence().clearCache();
054            }
055    
056            /**
057             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
058             */
059            public static void clearCache(BlogsStatsUser blogsStatsUser) {
060                    getPersistence().clearCache(blogsStatsUser);
061            }
062    
063            /**
064             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
065             */
066            public static long countWithDynamicQuery(DynamicQuery dynamicQuery) {
067                    return getPersistence().countWithDynamicQuery(dynamicQuery);
068            }
069    
070            /**
071             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
072             */
073            public static List<BlogsStatsUser> findWithDynamicQuery(
074                    DynamicQuery dynamicQuery) {
075                    return getPersistence().findWithDynamicQuery(dynamicQuery);
076            }
077    
078            /**
079             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
080             */
081            public static List<BlogsStatsUser> findWithDynamicQuery(
082                    DynamicQuery dynamicQuery, int start, int end) {
083                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
084            }
085    
086            /**
087             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
088             */
089            public static List<BlogsStatsUser> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator<BlogsStatsUser> orderByComparator) {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
099             */
100            public static BlogsStatsUser update(BlogsStatsUser blogsStatsUser) {
101                    return getPersistence().update(blogsStatsUser);
102            }
103    
104            /**
105             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
106             */
107            public static BlogsStatsUser update(BlogsStatsUser blogsStatsUser,
108                    ServiceContext serviceContext) {
109                    return getPersistence().update(blogsStatsUser, serviceContext);
110            }
111    
112            /**
113            * Returns all the blogs stats users where groupId = &#63;.
114            *
115            * @param groupId the group ID
116            * @return the matching blogs stats users
117            */
118            public static List<BlogsStatsUser> findByGroupId(long groupId) {
119                    return getPersistence().findByGroupId(groupId);
120            }
121    
122            /**
123            * Returns a range of all the blogs stats users where groupId = &#63;.
124            *
125            * <p>
126            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
127            * </p>
128            *
129            * @param groupId the group ID
130            * @param start the lower bound of the range of blogs stats users
131            * @param end the upper bound of the range of blogs stats users (not inclusive)
132            * @return the range of matching blogs stats users
133            */
134            public static List<BlogsStatsUser> findByGroupId(long groupId, int start,
135                    int end) {
136                    return getPersistence().findByGroupId(groupId, start, end);
137            }
138    
139            /**
140            * Returns an ordered range of all the blogs stats users where groupId = &#63;.
141            *
142            * <p>
143            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
144            * </p>
145            *
146            * @param groupId the group ID
147            * @param start the lower bound of the range of blogs stats users
148            * @param end the upper bound of the range of blogs stats users (not inclusive)
149            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
150            * @return the ordered range of matching blogs stats users
151            */
152            public static List<BlogsStatsUser> findByGroupId(long groupId, int start,
153                    int end, OrderByComparator<BlogsStatsUser> orderByComparator) {
154                    return getPersistence()
155                                       .findByGroupId(groupId, start, end, orderByComparator);
156            }
157    
158            /**
159            * Returns the first blogs stats user in the ordered set where groupId = &#63;.
160            *
161            * @param groupId the group ID
162            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
163            * @return the first matching blogs stats user
164            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
165            */
166            public static BlogsStatsUser findByGroupId_First(long groupId,
167                    OrderByComparator<BlogsStatsUser> orderByComparator)
168                    throws com.liferay.portlet.blogs.NoSuchStatsUserException {
169                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
170            }
171    
172            /**
173            * Returns the first blogs stats user in the ordered set where groupId = &#63;.
174            *
175            * @param groupId the group ID
176            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
177            * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
178            */
179            public static BlogsStatsUser fetchByGroupId_First(long groupId,
180                    OrderByComparator<BlogsStatsUser> orderByComparator) {
181                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
182            }
183    
184            /**
185            * Returns the last blogs stats user in the ordered set where groupId = &#63;.
186            *
187            * @param groupId the group ID
188            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
189            * @return the last matching blogs stats user
190            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
191            */
192            public static BlogsStatsUser findByGroupId_Last(long groupId,
193                    OrderByComparator<BlogsStatsUser> orderByComparator)
194                    throws com.liferay.portlet.blogs.NoSuchStatsUserException {
195                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
196            }
197    
198            /**
199            * Returns the last blogs stats user in the ordered set where groupId = &#63;.
200            *
201            * @param groupId the group ID
202            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
203            * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
204            */
205            public static BlogsStatsUser fetchByGroupId_Last(long groupId,
206                    OrderByComparator<BlogsStatsUser> orderByComparator) {
207                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
208            }
209    
210            /**
211            * Returns the blogs stats users before and after the current blogs stats user in the ordered set where groupId = &#63;.
212            *
213            * @param statsUserId the primary key of the current blogs stats user
214            * @param groupId the group ID
215            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
216            * @return the previous, current, and next blogs stats user
217            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
218            */
219            public static BlogsStatsUser[] findByGroupId_PrevAndNext(long statsUserId,
220                    long groupId, OrderByComparator<BlogsStatsUser> orderByComparator)
221                    throws com.liferay.portlet.blogs.NoSuchStatsUserException {
222                    return getPersistence()
223                                       .findByGroupId_PrevAndNext(statsUserId, groupId,
224                            orderByComparator);
225            }
226    
227            /**
228            * Removes all the blogs stats users where groupId = &#63; from the database.
229            *
230            * @param groupId the group ID
231            */
232            public static void removeByGroupId(long groupId) {
233                    getPersistence().removeByGroupId(groupId);
234            }
235    
236            /**
237            * Returns the number of blogs stats users where groupId = &#63;.
238            *
239            * @param groupId the group ID
240            * @return the number of matching blogs stats users
241            */
242            public static int countByGroupId(long groupId) {
243                    return getPersistence().countByGroupId(groupId);
244            }
245    
246            /**
247            * Returns all the blogs stats users where userId = &#63;.
248            *
249            * @param userId the user ID
250            * @return the matching blogs stats users
251            */
252            public static List<BlogsStatsUser> findByUserId(long userId) {
253                    return getPersistence().findByUserId(userId);
254            }
255    
256            /**
257            * Returns a range of all the blogs stats users where userId = &#63;.
258            *
259            * <p>
260            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>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.
261            * </p>
262            *
263            * @param userId the user ID
264            * @param start the lower bound of the range of blogs stats users
265            * @param end the upper bound of the range of blogs stats users (not inclusive)
266            * @return the range of matching blogs stats users
267            */
268            public static List<BlogsStatsUser> findByUserId(long userId, int start,
269                    int end) {
270                    return getPersistence().findByUserId(userId, start, end);
271            }
272    
273            /**
274            * Returns an ordered range of all the blogs stats users where userId = &#63;.
275            *
276            * <p>
277            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>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.
278            * </p>
279            *
280            * @param userId the user ID
281            * @param start the lower bound of the range of blogs stats users
282            * @param end the upper bound of the range of blogs stats users (not inclusive)
283            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
284            * @return the ordered range of matching blogs stats users
285            */
286            public static List<BlogsStatsUser> findByUserId(long userId, int start,
287                    int end, OrderByComparator<BlogsStatsUser> orderByComparator) {
288                    return getPersistence()
289                                       .findByUserId(userId, start, end, orderByComparator);
290            }
291    
292            /**
293            * Returns the first blogs stats user in the ordered set where userId = &#63;.
294            *
295            * @param userId the user ID
296            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
297            * @return the first matching blogs stats user
298            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
299            */
300            public static BlogsStatsUser findByUserId_First(long userId,
301                    OrderByComparator<BlogsStatsUser> orderByComparator)
302                    throws com.liferay.portlet.blogs.NoSuchStatsUserException {
303                    return getPersistence().findByUserId_First(userId, orderByComparator);
304            }
305    
306            /**
307            * Returns the first blogs stats user in the ordered set where userId = &#63;.
308            *
309            * @param userId the user ID
310            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
311            * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
312            */
313            public static BlogsStatsUser fetchByUserId_First(long userId,
314                    OrderByComparator<BlogsStatsUser> orderByComparator) {
315                    return getPersistence().fetchByUserId_First(userId, orderByComparator);
316            }
317    
318            /**
319            * Returns the last blogs stats user in the ordered set where userId = &#63;.
320            *
321            * @param userId the user ID
322            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
323            * @return the last matching blogs stats user
324            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
325            */
326            public static BlogsStatsUser findByUserId_Last(long userId,
327                    OrderByComparator<BlogsStatsUser> orderByComparator)
328                    throws com.liferay.portlet.blogs.NoSuchStatsUserException {
329                    return getPersistence().findByUserId_Last(userId, orderByComparator);
330            }
331    
332            /**
333            * Returns the last blogs stats user in the ordered set where userId = &#63;.
334            *
335            * @param userId the user ID
336            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
337            * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
338            */
339            public static BlogsStatsUser fetchByUserId_Last(long userId,
340                    OrderByComparator<BlogsStatsUser> orderByComparator) {
341                    return getPersistence().fetchByUserId_Last(userId, orderByComparator);
342            }
343    
344            /**
345            * Returns the blogs stats users before and after the current blogs stats user in the ordered set where userId = &#63;.
346            *
347            * @param statsUserId the primary key of the current blogs stats user
348            * @param userId the user ID
349            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
350            * @return the previous, current, and next blogs stats user
351            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
352            */
353            public static BlogsStatsUser[] findByUserId_PrevAndNext(long statsUserId,
354                    long userId, OrderByComparator<BlogsStatsUser> orderByComparator)
355                    throws com.liferay.portlet.blogs.NoSuchStatsUserException {
356                    return getPersistence()
357                                       .findByUserId_PrevAndNext(statsUserId, userId,
358                            orderByComparator);
359            }
360    
361            /**
362            * Removes all the blogs stats users where userId = &#63; from the database.
363            *
364            * @param userId the user ID
365            */
366            public static void removeByUserId(long userId) {
367                    getPersistence().removeByUserId(userId);
368            }
369    
370            /**
371            * Returns the number of blogs stats users where userId = &#63;.
372            *
373            * @param userId the user ID
374            * @return the number of matching blogs stats users
375            */
376            public static int countByUserId(long userId) {
377                    return getPersistence().countByUserId(userId);
378            }
379    
380            /**
381            * Returns the blogs stats user where groupId = &#63; and userId = &#63; or throws a {@link NoSuchStatsUserException} if it could not be found.
382            *
383            * @param groupId the group ID
384            * @param userId the user ID
385            * @return the matching blogs stats user
386            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
387            */
388            public static BlogsStatsUser findByG_U(long groupId, long userId)
389                    throws com.liferay.portlet.blogs.NoSuchStatsUserException {
390                    return getPersistence().findByG_U(groupId, userId);
391            }
392    
393            /**
394            * 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.
395            *
396            * @param groupId the group ID
397            * @param userId the user ID
398            * @return the matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
399            */
400            public static BlogsStatsUser fetchByG_U(long groupId, long userId) {
401                    return getPersistence().fetchByG_U(groupId, userId);
402            }
403    
404            /**
405            * 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.
406            *
407            * @param groupId the group ID
408            * @param userId the user ID
409            * @param retrieveFromCache whether to use the finder cache
410            * @return the matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
411            */
412            public static BlogsStatsUser fetchByG_U(long groupId, long userId,
413                    boolean retrieveFromCache) {
414                    return getPersistence().fetchByG_U(groupId, userId, retrieveFromCache);
415            }
416    
417            /**
418            * Removes the blogs stats user where groupId = &#63; and userId = &#63; from the database.
419            *
420            * @param groupId the group ID
421            * @param userId the user ID
422            * @return the blogs stats user that was removed
423            */
424            public static BlogsStatsUser removeByG_U(long groupId, long userId)
425                    throws com.liferay.portlet.blogs.NoSuchStatsUserException {
426                    return getPersistence().removeByG_U(groupId, userId);
427            }
428    
429            /**
430            * Returns the number of blogs stats users where groupId = &#63; and userId = &#63;.
431            *
432            * @param groupId the group ID
433            * @param userId the user ID
434            * @return the number of matching blogs stats users
435            */
436            public static int countByG_U(long groupId, long userId) {
437                    return getPersistence().countByG_U(groupId, userId);
438            }
439    
440            /**
441            * Returns all the blogs stats users where groupId = &#63; and entryCount &ne; &#63;.
442            *
443            * @param groupId the group ID
444            * @param entryCount the entry count
445            * @return the matching blogs stats users
446            */
447            public static List<BlogsStatsUser> findByG_NotE(long groupId, int entryCount) {
448                    return getPersistence().findByG_NotE(groupId, entryCount);
449            }
450    
451            /**
452            * Returns a range of all the blogs stats users where groupId = &#63; and entryCount &ne; &#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 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.
456            * </p>
457            *
458            * @param groupId the group ID
459            * @param entryCount the entry count
460            * @param start the lower bound of the range of blogs stats users
461            * @param end the upper bound of the range of blogs stats users (not inclusive)
462            * @return the range of matching blogs stats users
463            */
464            public static List<BlogsStatsUser> findByG_NotE(long groupId,
465                    int entryCount, int start, int end) {
466                    return getPersistence().findByG_NotE(groupId, entryCount, start, end);
467            }
468    
469            /**
470            * Returns an ordered range of all the blogs stats users where groupId = &#63; and entryCount &ne; &#63;.
471            *
472            * <p>
473            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>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.
474            * </p>
475            *
476            * @param groupId the group ID
477            * @param entryCount the entry count
478            * @param start the lower bound of the range of blogs stats users
479            * @param end the upper bound of the range of blogs stats users (not inclusive)
480            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
481            * @return the ordered range of matching blogs stats users
482            */
483            public static List<BlogsStatsUser> findByG_NotE(long groupId,
484                    int entryCount, int start, int end,
485                    OrderByComparator<BlogsStatsUser> orderByComparator) {
486                    return getPersistence()
487                                       .findByG_NotE(groupId, entryCount, start, end,
488                            orderByComparator);
489            }
490    
491            /**
492            * Returns the first blogs stats user in the ordered set where groupId = &#63; and entryCount &ne; &#63;.
493            *
494            * @param groupId the group ID
495            * @param entryCount the entry count
496            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
497            * @return the first matching blogs stats user
498            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
499            */
500            public static BlogsStatsUser findByG_NotE_First(long groupId,
501                    int entryCount, OrderByComparator<BlogsStatsUser> orderByComparator)
502                    throws com.liferay.portlet.blogs.NoSuchStatsUserException {
503                    return getPersistence()
504                                       .findByG_NotE_First(groupId, entryCount, orderByComparator);
505            }
506    
507            /**
508            * Returns the first blogs stats user in the ordered set where groupId = &#63; and entryCount &ne; &#63;.
509            *
510            * @param groupId the group ID
511            * @param entryCount the entry count
512            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
513            * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
514            */
515            public static BlogsStatsUser fetchByG_NotE_First(long groupId,
516                    int entryCount, OrderByComparator<BlogsStatsUser> orderByComparator) {
517                    return getPersistence()
518                                       .fetchByG_NotE_First(groupId, entryCount, orderByComparator);
519            }
520    
521            /**
522            * Returns the last blogs stats user in the ordered set where groupId = &#63; and entryCount &ne; &#63;.
523            *
524            * @param groupId the group ID
525            * @param entryCount the entry count
526            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
527            * @return the last matching blogs stats user
528            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
529            */
530            public static BlogsStatsUser findByG_NotE_Last(long groupId,
531                    int entryCount, OrderByComparator<BlogsStatsUser> orderByComparator)
532                    throws com.liferay.portlet.blogs.NoSuchStatsUserException {
533                    return getPersistence()
534                                       .findByG_NotE_Last(groupId, entryCount, orderByComparator);
535            }
536    
537            /**
538            * Returns the last blogs stats user in the ordered set where groupId = &#63; and entryCount &ne; &#63;.
539            *
540            * @param groupId the group ID
541            * @param entryCount the entry count
542            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
543            * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
544            */
545            public static BlogsStatsUser fetchByG_NotE_Last(long groupId,
546                    int entryCount, OrderByComparator<BlogsStatsUser> orderByComparator) {
547                    return getPersistence()
548                                       .fetchByG_NotE_Last(groupId, entryCount, orderByComparator);
549            }
550    
551            /**
552            * Returns the blogs stats users before and after the current blogs stats user in the ordered set where groupId = &#63; and entryCount &ne; &#63;.
553            *
554            * @param statsUserId the primary key of the current blogs stats user
555            * @param groupId the group ID
556            * @param entryCount the entry count
557            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
558            * @return the previous, current, and next blogs stats user
559            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
560            */
561            public static BlogsStatsUser[] findByG_NotE_PrevAndNext(long statsUserId,
562                    long groupId, int entryCount,
563                    OrderByComparator<BlogsStatsUser> orderByComparator)
564                    throws com.liferay.portlet.blogs.NoSuchStatsUserException {
565                    return getPersistence()
566                                       .findByG_NotE_PrevAndNext(statsUserId, groupId, entryCount,
567                            orderByComparator);
568            }
569    
570            /**
571            * Removes all the blogs stats users where groupId = &#63; and entryCount &ne; &#63; from the database.
572            *
573            * @param groupId the group ID
574            * @param entryCount the entry count
575            */
576            public static void removeByG_NotE(long groupId, int entryCount) {
577                    getPersistence().removeByG_NotE(groupId, entryCount);
578            }
579    
580            /**
581            * Returns the number of blogs stats users where groupId = &#63; and entryCount &ne; &#63;.
582            *
583            * @param groupId the group ID
584            * @param entryCount the entry count
585            * @return the number of matching blogs stats users
586            */
587            public static int countByG_NotE(long groupId, int entryCount) {
588                    return getPersistence().countByG_NotE(groupId, entryCount);
589            }
590    
591            /**
592            * Returns all the blogs stats users where companyId = &#63; and entryCount &ne; &#63;.
593            *
594            * @param companyId the company ID
595            * @param entryCount the entry count
596            * @return the matching blogs stats users
597            */
598            public static List<BlogsStatsUser> findByC_NotE(long companyId,
599                    int entryCount) {
600                    return getPersistence().findByC_NotE(companyId, entryCount);
601            }
602    
603            /**
604            * Returns a range of all the blogs stats users where companyId = &#63; and entryCount &ne; &#63;.
605            *
606            * <p>
607            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
608            * </p>
609            *
610            * @param companyId the company ID
611            * @param entryCount the entry count
612            * @param start the lower bound of the range of blogs stats users
613            * @param end the upper bound of the range of blogs stats users (not inclusive)
614            * @return the range of matching blogs stats users
615            */
616            public static List<BlogsStatsUser> findByC_NotE(long companyId,
617                    int entryCount, int start, int end) {
618                    return getPersistence().findByC_NotE(companyId, entryCount, start, end);
619            }
620    
621            /**
622            * Returns an ordered range of all the blogs stats users where companyId = &#63; and entryCount &ne; &#63;.
623            *
624            * <p>
625            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>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.
626            * </p>
627            *
628            * @param companyId the company ID
629            * @param entryCount the entry count
630            * @param start the lower bound of the range of blogs stats users
631            * @param end the upper bound of the range of blogs stats users (not inclusive)
632            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
633            * @return the ordered range of matching blogs stats users
634            */
635            public static List<BlogsStatsUser> findByC_NotE(long companyId,
636                    int entryCount, int start, int end,
637                    OrderByComparator<BlogsStatsUser> orderByComparator) {
638                    return getPersistence()
639                                       .findByC_NotE(companyId, entryCount, start, end,
640                            orderByComparator);
641            }
642    
643            /**
644            * Returns the first blogs stats user in the ordered set where companyId = &#63; and entryCount &ne; &#63;.
645            *
646            * @param companyId the company ID
647            * @param entryCount the entry count
648            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
649            * @return the first matching blogs stats user
650            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
651            */
652            public static BlogsStatsUser findByC_NotE_First(long companyId,
653                    int entryCount, OrderByComparator<BlogsStatsUser> orderByComparator)
654                    throws com.liferay.portlet.blogs.NoSuchStatsUserException {
655                    return getPersistence()
656                                       .findByC_NotE_First(companyId, entryCount, orderByComparator);
657            }
658    
659            /**
660            * Returns the first blogs stats user in the ordered set where companyId = &#63; and entryCount &ne; &#63;.
661            *
662            * @param companyId the company ID
663            * @param entryCount the entry count
664            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
665            * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
666            */
667            public static BlogsStatsUser fetchByC_NotE_First(long companyId,
668                    int entryCount, OrderByComparator<BlogsStatsUser> orderByComparator) {
669                    return getPersistence()
670                                       .fetchByC_NotE_First(companyId, entryCount, orderByComparator);
671            }
672    
673            /**
674            * Returns the last blogs stats user in the ordered set where companyId = &#63; and entryCount &ne; &#63;.
675            *
676            * @param companyId the company ID
677            * @param entryCount the entry count
678            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
679            * @return the last matching blogs stats user
680            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
681            */
682            public static BlogsStatsUser findByC_NotE_Last(long companyId,
683                    int entryCount, OrderByComparator<BlogsStatsUser> orderByComparator)
684                    throws com.liferay.portlet.blogs.NoSuchStatsUserException {
685                    return getPersistence()
686                                       .findByC_NotE_Last(companyId, entryCount, orderByComparator);
687            }
688    
689            /**
690            * Returns the last blogs stats user in the ordered set where companyId = &#63; and entryCount &ne; &#63;.
691            *
692            * @param companyId the company ID
693            * @param entryCount the entry count
694            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
695            * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
696            */
697            public static BlogsStatsUser fetchByC_NotE_Last(long companyId,
698                    int entryCount, OrderByComparator<BlogsStatsUser> orderByComparator) {
699                    return getPersistence()
700                                       .fetchByC_NotE_Last(companyId, entryCount, orderByComparator);
701            }
702    
703            /**
704            * Returns the blogs stats users before and after the current blogs stats user in the ordered set where companyId = &#63; and entryCount &ne; &#63;.
705            *
706            * @param statsUserId the primary key of the current blogs stats user
707            * @param companyId the company ID
708            * @param entryCount the entry count
709            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
710            * @return the previous, current, and next blogs stats user
711            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
712            */
713            public static BlogsStatsUser[] findByC_NotE_PrevAndNext(long statsUserId,
714                    long companyId, int entryCount,
715                    OrderByComparator<BlogsStatsUser> orderByComparator)
716                    throws com.liferay.portlet.blogs.NoSuchStatsUserException {
717                    return getPersistence()
718                                       .findByC_NotE_PrevAndNext(statsUserId, companyId,
719                            entryCount, orderByComparator);
720            }
721    
722            /**
723            * Removes all the blogs stats users where companyId = &#63; and entryCount &ne; &#63; from the database.
724            *
725            * @param companyId the company ID
726            * @param entryCount the entry count
727            */
728            public static void removeByC_NotE(long companyId, int entryCount) {
729                    getPersistence().removeByC_NotE(companyId, entryCount);
730            }
731    
732            /**
733            * Returns the number of blogs stats users where companyId = &#63; and entryCount &ne; &#63;.
734            *
735            * @param companyId the company ID
736            * @param entryCount the entry count
737            * @return the number of matching blogs stats users
738            */
739            public static int countByC_NotE(long companyId, int entryCount) {
740                    return getPersistence().countByC_NotE(companyId, entryCount);
741            }
742    
743            /**
744            * Returns all the blogs stats users where userId = &#63; and lastPostDate = &#63;.
745            *
746            * @param userId the user ID
747            * @param lastPostDate the last post date
748            * @return the matching blogs stats users
749            */
750            public static List<BlogsStatsUser> findByU_L(long userId,
751                    java.util.Date lastPostDate) {
752                    return getPersistence().findByU_L(userId, lastPostDate);
753            }
754    
755            /**
756            * Returns a range of all the blogs stats users where userId = &#63; and lastPostDate = &#63;.
757            *
758            * <p>
759            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
760            * </p>
761            *
762            * @param userId the user ID
763            * @param lastPostDate the last post date
764            * @param start the lower bound of the range of blogs stats users
765            * @param end the upper bound of the range of blogs stats users (not inclusive)
766            * @return the range of matching blogs stats users
767            */
768            public static List<BlogsStatsUser> findByU_L(long userId,
769                    java.util.Date lastPostDate, int start, int end) {
770                    return getPersistence().findByU_L(userId, lastPostDate, start, end);
771            }
772    
773            /**
774            * Returns an ordered range of all the blogs stats users where userId = &#63; and lastPostDate = &#63;.
775            *
776            * <p>
777            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
778            * </p>
779            *
780            * @param userId the user ID
781            * @param lastPostDate the last post date
782            * @param start the lower bound of the range of blogs stats users
783            * @param end the upper bound of the range of blogs stats users (not inclusive)
784            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
785            * @return the ordered range of matching blogs stats users
786            */
787            public static List<BlogsStatsUser> findByU_L(long userId,
788                    java.util.Date lastPostDate, int start, int end,
789                    OrderByComparator<BlogsStatsUser> orderByComparator) {
790                    return getPersistence()
791                                       .findByU_L(userId, lastPostDate, start, end,
792                            orderByComparator);
793            }
794    
795            /**
796            * Returns the first blogs stats user in the ordered set where userId = &#63; and lastPostDate = &#63;.
797            *
798            * @param userId the user ID
799            * @param lastPostDate the last post date
800            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
801            * @return the first matching blogs stats user
802            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
803            */
804            public static BlogsStatsUser findByU_L_First(long userId,
805                    java.util.Date lastPostDate,
806                    OrderByComparator<BlogsStatsUser> orderByComparator)
807                    throws com.liferay.portlet.blogs.NoSuchStatsUserException {
808                    return getPersistence()
809                                       .findByU_L_First(userId, lastPostDate, orderByComparator);
810            }
811    
812            /**
813            * Returns the first blogs stats user in the ordered set where userId = &#63; and lastPostDate = &#63;.
814            *
815            * @param userId the user ID
816            * @param lastPostDate the last post date
817            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
818            * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
819            */
820            public static BlogsStatsUser fetchByU_L_First(long userId,
821                    java.util.Date lastPostDate,
822                    OrderByComparator<BlogsStatsUser> orderByComparator) {
823                    return getPersistence()
824                                       .fetchByU_L_First(userId, lastPostDate, orderByComparator);
825            }
826    
827            /**
828            * Returns the last blogs stats user in the ordered set where userId = &#63; and lastPostDate = &#63;.
829            *
830            * @param userId the user ID
831            * @param lastPostDate the last post date
832            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
833            * @return the last matching blogs stats user
834            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
835            */
836            public static BlogsStatsUser findByU_L_Last(long userId,
837                    java.util.Date lastPostDate,
838                    OrderByComparator<BlogsStatsUser> orderByComparator)
839                    throws com.liferay.portlet.blogs.NoSuchStatsUserException {
840                    return getPersistence()
841                                       .findByU_L_Last(userId, lastPostDate, orderByComparator);
842            }
843    
844            /**
845            * Returns the last blogs stats user in the ordered set where userId = &#63; and lastPostDate = &#63;.
846            *
847            * @param userId the user ID
848            * @param lastPostDate the last post date
849            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
850            * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
851            */
852            public static BlogsStatsUser fetchByU_L_Last(long userId,
853                    java.util.Date lastPostDate,
854                    OrderByComparator<BlogsStatsUser> orderByComparator) {
855                    return getPersistence()
856                                       .fetchByU_L_Last(userId, lastPostDate, orderByComparator);
857            }
858    
859            /**
860            * Returns the blogs stats users before and after the current blogs stats user in the ordered set where userId = &#63; and lastPostDate = &#63;.
861            *
862            * @param statsUserId the primary key of the current blogs stats user
863            * @param userId the user ID
864            * @param lastPostDate the last post date
865            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
866            * @return the previous, current, and next blogs stats user
867            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
868            */
869            public static BlogsStatsUser[] findByU_L_PrevAndNext(long statsUserId,
870                    long userId, java.util.Date lastPostDate,
871                    OrderByComparator<BlogsStatsUser> orderByComparator)
872                    throws com.liferay.portlet.blogs.NoSuchStatsUserException {
873                    return getPersistence()
874                                       .findByU_L_PrevAndNext(statsUserId, userId, lastPostDate,
875                            orderByComparator);
876            }
877    
878            /**
879            * Removes all the blogs stats users where userId = &#63; and lastPostDate = &#63; from the database.
880            *
881            * @param userId the user ID
882            * @param lastPostDate the last post date
883            */
884            public static void removeByU_L(long userId, java.util.Date lastPostDate) {
885                    getPersistence().removeByU_L(userId, lastPostDate);
886            }
887    
888            /**
889            * Returns the number of blogs stats users where userId = &#63; and lastPostDate = &#63;.
890            *
891            * @param userId the user ID
892            * @param lastPostDate the last post date
893            * @return the number of matching blogs stats users
894            */
895            public static int countByU_L(long userId, java.util.Date lastPostDate) {
896                    return getPersistence().countByU_L(userId, lastPostDate);
897            }
898    
899            /**
900            * Caches the blogs stats user in the entity cache if it is enabled.
901            *
902            * @param blogsStatsUser the blogs stats user
903            */
904            public static void cacheResult(BlogsStatsUser blogsStatsUser) {
905                    getPersistence().cacheResult(blogsStatsUser);
906            }
907    
908            /**
909            * Caches the blogs stats users in the entity cache if it is enabled.
910            *
911            * @param blogsStatsUsers the blogs stats users
912            */
913            public static void cacheResult(List<BlogsStatsUser> blogsStatsUsers) {
914                    getPersistence().cacheResult(blogsStatsUsers);
915            }
916    
917            /**
918            * Creates a new blogs stats user with the primary key. Does not add the blogs stats user to the database.
919            *
920            * @param statsUserId the primary key for the new blogs stats user
921            * @return the new blogs stats user
922            */
923            public static BlogsStatsUser create(long statsUserId) {
924                    return getPersistence().create(statsUserId);
925            }
926    
927            /**
928            * Removes the blogs stats user with the primary key from the database. Also notifies the appropriate model listeners.
929            *
930            * @param statsUserId the primary key of the blogs stats user
931            * @return the blogs stats user that was removed
932            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
933            */
934            public static BlogsStatsUser remove(long statsUserId)
935                    throws com.liferay.portlet.blogs.NoSuchStatsUserException {
936                    return getPersistence().remove(statsUserId);
937            }
938    
939            public static BlogsStatsUser updateImpl(BlogsStatsUser blogsStatsUser) {
940                    return getPersistence().updateImpl(blogsStatsUser);
941            }
942    
943            /**
944            * Returns the blogs stats user with the primary key or throws a {@link NoSuchStatsUserException} if it could not be found.
945            *
946            * @param statsUserId the primary key of the blogs stats user
947            * @return the blogs stats user
948            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
949            */
950            public static BlogsStatsUser findByPrimaryKey(long statsUserId)
951                    throws com.liferay.portlet.blogs.NoSuchStatsUserException {
952                    return getPersistence().findByPrimaryKey(statsUserId);
953            }
954    
955            /**
956            * Returns the blogs stats user with the primary key or returns <code>null</code> if it could not be found.
957            *
958            * @param statsUserId the primary key of the blogs stats user
959            * @return the blogs stats user, or <code>null</code> if a blogs stats user with the primary key could not be found
960            */
961            public static BlogsStatsUser fetchByPrimaryKey(long statsUserId) {
962                    return getPersistence().fetchByPrimaryKey(statsUserId);
963            }
964    
965            public static java.util.Map<java.io.Serializable, BlogsStatsUser> fetchByPrimaryKeys(
966                    java.util.Set<java.io.Serializable> primaryKeys) {
967                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
968            }
969    
970            /**
971            * Returns all the blogs stats users.
972            *
973            * @return the blogs stats users
974            */
975            public static List<BlogsStatsUser> findAll() {
976                    return getPersistence().findAll();
977            }
978    
979            /**
980            * Returns a range of all the blogs stats users.
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 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.
984            * </p>
985            *
986            * @param start the lower bound of the range of blogs stats users
987            * @param end the upper bound of the range of blogs stats users (not inclusive)
988            * @return the range of blogs stats users
989            */
990            public static List<BlogsStatsUser> findAll(int start, int end) {
991                    return getPersistence().findAll(start, end);
992            }
993    
994            /**
995            * Returns an ordered range of all the blogs stats users.
996            *
997            * <p>
998            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>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.
999            * </p>
1000            *
1001            * @param start the lower bound of the range of blogs stats users
1002            * @param end the upper bound of the range of blogs stats users (not inclusive)
1003            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1004            * @return the ordered range of blogs stats users
1005            */
1006            public static List<BlogsStatsUser> findAll(int start, int end,
1007                    OrderByComparator<BlogsStatsUser> orderByComparator) {
1008                    return getPersistence().findAll(start, end, orderByComparator);
1009            }
1010    
1011            /**
1012            * Removes all the blogs stats users from the database.
1013            */
1014            public static void removeAll() {
1015                    getPersistence().removeAll();
1016            }
1017    
1018            /**
1019            * Returns the number of blogs stats users.
1020            *
1021            * @return the number of blogs stats users
1022            */
1023            public static int countAll() {
1024                    return getPersistence().countAll();
1025            }
1026    
1027            public static BlogsStatsUserPersistence getPersistence() {
1028                    if (_persistence == null) {
1029                            _persistence = (BlogsStatsUserPersistence)PortalBeanLocatorUtil.locate(BlogsStatsUserPersistence.class.getName());
1030    
1031                            ReferenceRegistry.registerReference(BlogsStatsUserUtil.class,
1032                                    "_persistence");
1033                    }
1034    
1035                    return _persistence;
1036            }
1037    
1038            /**
1039             * @deprecated As of 6.2.0
1040             */
1041            @Deprecated
1042            public void setPersistence(BlogsStatsUserPersistence persistence) {
1043            }
1044    
1045            private static BlogsStatsUserPersistence _persistence;
1046    }