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 an ordered range of all the blogs stats users where groupId = &#63;.
160            *
161            * <p>
162            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>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.
163            * </p>
164            *
165            * @param groupId the group ID
166            * @param start the lower bound of the range of blogs stats users
167            * @param end the upper bound of the range of blogs stats users (not inclusive)
168            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
169            * @param retrieveFromCache whether to retrieve from the finder cache
170            * @return the ordered range of matching blogs stats users
171            */
172            public static List<BlogsStatsUser> findByGroupId(long groupId, int start,
173                    int end, OrderByComparator<BlogsStatsUser> orderByComparator,
174                    boolean retrieveFromCache) {
175                    return getPersistence()
176                                       .findByGroupId(groupId, start, end, orderByComparator,
177                            retrieveFromCache);
178            }
179    
180            /**
181            * Returns the first blogs stats user in the ordered set where groupId = &#63;.
182            *
183            * @param groupId the group ID
184            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
185            * @return the first matching blogs stats user
186            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
187            */
188            public static BlogsStatsUser findByGroupId_First(long groupId,
189                    OrderByComparator<BlogsStatsUser> orderByComparator)
190                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
191                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
192            }
193    
194            /**
195            * Returns the first blogs stats user in the ordered set where groupId = &#63;.
196            *
197            * @param groupId the group ID
198            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
199            * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
200            */
201            public static BlogsStatsUser fetchByGroupId_First(long groupId,
202                    OrderByComparator<BlogsStatsUser> orderByComparator) {
203                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
204            }
205    
206            /**
207            * Returns the last blogs stats user in the ordered set where groupId = &#63;.
208            *
209            * @param groupId the group ID
210            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
211            * @return the last matching blogs stats user
212            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
213            */
214            public static BlogsStatsUser findByGroupId_Last(long groupId,
215                    OrderByComparator<BlogsStatsUser> orderByComparator)
216                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
217                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
218            }
219    
220            /**
221            * Returns the last blogs stats user in the ordered set where groupId = &#63;.
222            *
223            * @param groupId the group ID
224            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
225            * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
226            */
227            public static BlogsStatsUser fetchByGroupId_Last(long groupId,
228                    OrderByComparator<BlogsStatsUser> orderByComparator) {
229                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
230            }
231    
232            /**
233            * Returns the blogs stats users before and after the current blogs stats user in the ordered set where groupId = &#63;.
234            *
235            * @param statsUserId the primary key of the current blogs stats user
236            * @param groupId the group ID
237            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
238            * @return the previous, current, and next blogs stats user
239            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
240            */
241            public static BlogsStatsUser[] findByGroupId_PrevAndNext(long statsUserId,
242                    long groupId, OrderByComparator<BlogsStatsUser> orderByComparator)
243                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
244                    return getPersistence()
245                                       .findByGroupId_PrevAndNext(statsUserId, groupId,
246                            orderByComparator);
247            }
248    
249            /**
250            * Removes all the blogs stats users where groupId = &#63; from the database.
251            *
252            * @param groupId the group ID
253            */
254            public static void removeByGroupId(long groupId) {
255                    getPersistence().removeByGroupId(groupId);
256            }
257    
258            /**
259            * Returns the number of blogs stats users where groupId = &#63;.
260            *
261            * @param groupId the group ID
262            * @return the number of matching blogs stats users
263            */
264            public static int countByGroupId(long groupId) {
265                    return getPersistence().countByGroupId(groupId);
266            }
267    
268            /**
269            * Returns all the blogs stats users where userId = &#63;.
270            *
271            * @param userId the user ID
272            * @return the matching blogs stats users
273            */
274            public static List<BlogsStatsUser> findByUserId(long userId) {
275                    return getPersistence().findByUserId(userId);
276            }
277    
278            /**
279            * Returns a range of all the blogs stats users where userId = &#63;.
280            *
281            * <p>
282            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>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.
283            * </p>
284            *
285            * @param userId the user ID
286            * @param start the lower bound of the range of blogs stats users
287            * @param end the upper bound of the range of blogs stats users (not inclusive)
288            * @return the range of matching blogs stats users
289            */
290            public static List<BlogsStatsUser> findByUserId(long userId, int start,
291                    int end) {
292                    return getPersistence().findByUserId(userId, start, end);
293            }
294    
295            /**
296            * Returns an ordered range of all the blogs stats users where userId = &#63;.
297            *
298            * <p>
299            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>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.
300            * </p>
301            *
302            * @param userId the user ID
303            * @param start the lower bound of the range of blogs stats users
304            * @param end the upper bound of the range of blogs stats users (not inclusive)
305            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
306            * @return the ordered range of matching blogs stats users
307            */
308            public static List<BlogsStatsUser> findByUserId(long userId, int start,
309                    int end, OrderByComparator<BlogsStatsUser> orderByComparator) {
310                    return getPersistence()
311                                       .findByUserId(userId, start, end, orderByComparator);
312            }
313    
314            /**
315            * Returns an ordered range of all the blogs stats users where userId = &#63;.
316            *
317            * <p>
318            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>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.
319            * </p>
320            *
321            * @param userId the user ID
322            * @param start the lower bound of the range of blogs stats users
323            * @param end the upper bound of the range of blogs stats users (not inclusive)
324            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
325            * @param retrieveFromCache whether to retrieve from the finder cache
326            * @return the ordered range of matching blogs stats users
327            */
328            public static List<BlogsStatsUser> findByUserId(long userId, int start,
329                    int end, OrderByComparator<BlogsStatsUser> orderByComparator,
330                    boolean retrieveFromCache) {
331                    return getPersistence()
332                                       .findByUserId(userId, start, end, orderByComparator,
333                            retrieveFromCache);
334            }
335    
336            /**
337            * Returns the first blogs stats user in the ordered set where userId = &#63;.
338            *
339            * @param userId the user ID
340            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
341            * @return the first matching blogs stats user
342            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
343            */
344            public static BlogsStatsUser findByUserId_First(long userId,
345                    OrderByComparator<BlogsStatsUser> orderByComparator)
346                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
347                    return getPersistence().findByUserId_First(userId, orderByComparator);
348            }
349    
350            /**
351            * Returns the first blogs stats user in the ordered set where userId = &#63;.
352            *
353            * @param userId the user ID
354            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
355            * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
356            */
357            public static BlogsStatsUser fetchByUserId_First(long userId,
358                    OrderByComparator<BlogsStatsUser> orderByComparator) {
359                    return getPersistence().fetchByUserId_First(userId, orderByComparator);
360            }
361    
362            /**
363            * Returns the last blogs stats user in the ordered set where userId = &#63;.
364            *
365            * @param userId the user ID
366            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
367            * @return the last matching blogs stats user
368            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
369            */
370            public static BlogsStatsUser findByUserId_Last(long userId,
371                    OrderByComparator<BlogsStatsUser> orderByComparator)
372                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
373                    return getPersistence().findByUserId_Last(userId, orderByComparator);
374            }
375    
376            /**
377            * Returns the last blogs stats user in the ordered set where userId = &#63;.
378            *
379            * @param userId the user ID
380            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
381            * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
382            */
383            public static BlogsStatsUser fetchByUserId_Last(long userId,
384                    OrderByComparator<BlogsStatsUser> orderByComparator) {
385                    return getPersistence().fetchByUserId_Last(userId, orderByComparator);
386            }
387    
388            /**
389            * Returns the blogs stats users before and after the current blogs stats user in the ordered set where userId = &#63;.
390            *
391            * @param statsUserId the primary key of the current blogs stats user
392            * @param userId the user ID
393            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
394            * @return the previous, current, and next blogs stats user
395            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
396            */
397            public static BlogsStatsUser[] findByUserId_PrevAndNext(long statsUserId,
398                    long userId, OrderByComparator<BlogsStatsUser> orderByComparator)
399                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
400                    return getPersistence()
401                                       .findByUserId_PrevAndNext(statsUserId, userId,
402                            orderByComparator);
403            }
404    
405            /**
406            * Removes all the blogs stats users where userId = &#63; from the database.
407            *
408            * @param userId the user ID
409            */
410            public static void removeByUserId(long userId) {
411                    getPersistence().removeByUserId(userId);
412            }
413    
414            /**
415            * Returns the number of blogs stats users where userId = &#63;.
416            *
417            * @param userId the user ID
418            * @return the number of matching blogs stats users
419            */
420            public static int countByUserId(long userId) {
421                    return getPersistence().countByUserId(userId);
422            }
423    
424            /**
425            * Returns the blogs stats user where groupId = &#63; and userId = &#63; or throws a {@link NoSuchStatsUserException} if it could not be found.
426            *
427            * @param groupId the group ID
428            * @param userId the user ID
429            * @return the matching blogs stats user
430            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
431            */
432            public static BlogsStatsUser findByG_U(long groupId, long userId)
433                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
434                    return getPersistence().findByG_U(groupId, userId);
435            }
436    
437            /**
438            * 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.
439            *
440            * @param groupId the group ID
441            * @param userId the user ID
442            * @return the matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
443            */
444            public static BlogsStatsUser fetchByG_U(long groupId, long userId) {
445                    return getPersistence().fetchByG_U(groupId, userId);
446            }
447    
448            /**
449            * 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.
450            *
451            * @param groupId the group ID
452            * @param userId the user ID
453            * @param retrieveFromCache whether to retrieve from the finder cache
454            * @return the matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
455            */
456            public static BlogsStatsUser fetchByG_U(long groupId, long userId,
457                    boolean retrieveFromCache) {
458                    return getPersistence().fetchByG_U(groupId, userId, retrieveFromCache);
459            }
460    
461            /**
462            * Removes the blogs stats user where groupId = &#63; and userId = &#63; from the database.
463            *
464            * @param groupId the group ID
465            * @param userId the user ID
466            * @return the blogs stats user that was removed
467            */
468            public static BlogsStatsUser removeByG_U(long groupId, long userId)
469                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
470                    return getPersistence().removeByG_U(groupId, userId);
471            }
472    
473            /**
474            * Returns the number of blogs stats users where groupId = &#63; and userId = &#63;.
475            *
476            * @param groupId the group ID
477            * @param userId the user ID
478            * @return the number of matching blogs stats users
479            */
480            public static int countByG_U(long groupId, long userId) {
481                    return getPersistence().countByG_U(groupId, userId);
482            }
483    
484            /**
485            * Returns all the blogs stats users where groupId = &#63; and entryCount &ne; &#63;.
486            *
487            * @param groupId the group ID
488            * @param entryCount the entry count
489            * @return the matching blogs stats users
490            */
491            public static List<BlogsStatsUser> findByG_NotE(long groupId, int entryCount) {
492                    return getPersistence().findByG_NotE(groupId, entryCount);
493            }
494    
495            /**
496            * Returns a range of all the blogs stats users where groupId = &#63; and entryCount &ne; &#63;.
497            *
498            * <p>
499            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>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.
500            * </p>
501            *
502            * @param groupId the group ID
503            * @param entryCount the entry count
504            * @param start the lower bound of the range of blogs stats users
505            * @param end the upper bound of the range of blogs stats users (not inclusive)
506            * @return the range of matching blogs stats users
507            */
508            public static List<BlogsStatsUser> findByG_NotE(long groupId,
509                    int entryCount, int start, int end) {
510                    return getPersistence().findByG_NotE(groupId, entryCount, start, end);
511            }
512    
513            /**
514            * Returns an ordered range of all the blogs stats users where groupId = &#63; and entryCount &ne; &#63;.
515            *
516            * <p>
517            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
518            * </p>
519            *
520            * @param groupId the group ID
521            * @param entryCount the entry count
522            * @param start the lower bound of the range of blogs stats users
523            * @param end the upper bound of the range of blogs stats users (not inclusive)
524            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
525            * @return the ordered range of matching blogs stats users
526            */
527            public static List<BlogsStatsUser> findByG_NotE(long groupId,
528                    int entryCount, int start, int end,
529                    OrderByComparator<BlogsStatsUser> orderByComparator) {
530                    return getPersistence()
531                                       .findByG_NotE(groupId, entryCount, start, end,
532                            orderByComparator);
533            }
534    
535            /**
536            * Returns an ordered range of all the blogs stats users where groupId = &#63; and entryCount &ne; &#63;.
537            *
538            * <p>
539            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>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.
540            * </p>
541            *
542            * @param groupId the group ID
543            * @param entryCount the entry count
544            * @param start the lower bound of the range of blogs stats users
545            * @param end the upper bound of the range of blogs stats users (not inclusive)
546            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
547            * @param retrieveFromCache whether to retrieve from the finder cache
548            * @return the ordered range of matching blogs stats users
549            */
550            public static List<BlogsStatsUser> findByG_NotE(long groupId,
551                    int entryCount, int start, int end,
552                    OrderByComparator<BlogsStatsUser> orderByComparator,
553                    boolean retrieveFromCache) {
554                    return getPersistence()
555                                       .findByG_NotE(groupId, entryCount, start, end,
556                            orderByComparator, retrieveFromCache);
557            }
558    
559            /**
560            * Returns the first blogs stats user in the ordered set where groupId = &#63; and entryCount &ne; &#63;.
561            *
562            * @param groupId the group ID
563            * @param entryCount the entry count
564            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
565            * @return the first matching blogs stats user
566            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
567            */
568            public static BlogsStatsUser findByG_NotE_First(long groupId,
569                    int entryCount, OrderByComparator<BlogsStatsUser> orderByComparator)
570                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
571                    return getPersistence()
572                                       .findByG_NotE_First(groupId, entryCount, orderByComparator);
573            }
574    
575            /**
576            * Returns the first blogs stats user in the ordered set where groupId = &#63; and entryCount &ne; &#63;.
577            *
578            * @param groupId the group ID
579            * @param entryCount the entry count
580            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
581            * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
582            */
583            public static BlogsStatsUser fetchByG_NotE_First(long groupId,
584                    int entryCount, OrderByComparator<BlogsStatsUser> orderByComparator) {
585                    return getPersistence()
586                                       .fetchByG_NotE_First(groupId, entryCount, orderByComparator);
587            }
588    
589            /**
590            * Returns the last blogs stats user in the ordered set where groupId = &#63; and entryCount &ne; &#63;.
591            *
592            * @param groupId the group 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 static BlogsStatsUser findByG_NotE_Last(long groupId,
599                    int entryCount, OrderByComparator<BlogsStatsUser> orderByComparator)
600                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
601                    return getPersistence()
602                                       .findByG_NotE_Last(groupId, entryCount, orderByComparator);
603            }
604    
605            /**
606            * Returns the last blogs stats user in the ordered set where groupId = &#63; and entryCount &ne; &#63;.
607            *
608            * @param groupId the group ID
609            * @param entryCount the entry count
610            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
611            * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
612            */
613            public static BlogsStatsUser fetchByG_NotE_Last(long groupId,
614                    int entryCount, OrderByComparator<BlogsStatsUser> orderByComparator) {
615                    return getPersistence()
616                                       .fetchByG_NotE_Last(groupId, entryCount, orderByComparator);
617            }
618    
619            /**
620            * Returns the blogs stats users before and after the current blogs stats user in the ordered set where groupId = &#63; and entryCount &ne; &#63;.
621            *
622            * @param statsUserId the primary key of the current blogs stats user
623            * @param groupId the group ID
624            * @param entryCount the entry count
625            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
626            * @return the previous, current, and next blogs stats user
627            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
628            */
629            public static BlogsStatsUser[] findByG_NotE_PrevAndNext(long statsUserId,
630                    long groupId, int entryCount,
631                    OrderByComparator<BlogsStatsUser> orderByComparator)
632                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
633                    return getPersistence()
634                                       .findByG_NotE_PrevAndNext(statsUserId, groupId, entryCount,
635                            orderByComparator);
636            }
637    
638            /**
639            * Removes all the blogs stats users where groupId = &#63; and entryCount &ne; &#63; from the database.
640            *
641            * @param groupId the group ID
642            * @param entryCount the entry count
643            */
644            public static void removeByG_NotE(long groupId, int entryCount) {
645                    getPersistence().removeByG_NotE(groupId, entryCount);
646            }
647    
648            /**
649            * Returns the number of blogs stats users where groupId = &#63; and entryCount &ne; &#63;.
650            *
651            * @param groupId the group ID
652            * @param entryCount the entry count
653            * @return the number of matching blogs stats users
654            */
655            public static int countByG_NotE(long groupId, int entryCount) {
656                    return getPersistence().countByG_NotE(groupId, entryCount);
657            }
658    
659            /**
660            * Returns all the blogs stats users where companyId = &#63; and entryCount &ne; &#63;.
661            *
662            * @param companyId the company ID
663            * @param entryCount the entry count
664            * @return the matching blogs stats users
665            */
666            public static List<BlogsStatsUser> findByC_NotE(long companyId,
667                    int entryCount) {
668                    return getPersistence().findByC_NotE(companyId, entryCount);
669            }
670    
671            /**
672            * Returns a range of all the blogs stats users where companyId = &#63; and entryCount &ne; &#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 companyId the company ID
679            * @param entryCount the entry count
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            * @return the range of matching blogs stats users
683            */
684            public static List<BlogsStatsUser> findByC_NotE(long companyId,
685                    int entryCount, int start, int end) {
686                    return getPersistence().findByC_NotE(companyId, entryCount, start, end);
687            }
688    
689            /**
690            * Returns an ordered range of all the blogs stats users where companyId = &#63; and entryCount &ne; &#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 companyId the company ID
697            * @param entryCount the entry count
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            * @return the ordered range of matching blogs stats users
702            */
703            public static List<BlogsStatsUser> findByC_NotE(long companyId,
704                    int entryCount, int start, int end,
705                    OrderByComparator<BlogsStatsUser> orderByComparator) {
706                    return getPersistence()
707                                       .findByC_NotE(companyId, entryCount, start, end,
708                            orderByComparator);
709            }
710    
711            /**
712            * Returns an ordered range of all the blogs stats users where companyId = &#63; and entryCount &ne; &#63;.
713            *
714            * <p>
715            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>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.
716            * </p>
717            *
718            * @param companyId the company ID
719            * @param entryCount the entry count
720            * @param start the lower bound of the range of blogs stats users
721            * @param end the upper bound of the range of blogs stats users (not inclusive)
722            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
723            * @param retrieveFromCache whether to retrieve from the finder cache
724            * @return the ordered range of matching blogs stats users
725            */
726            public static List<BlogsStatsUser> findByC_NotE(long companyId,
727                    int entryCount, int start, int end,
728                    OrderByComparator<BlogsStatsUser> orderByComparator,
729                    boolean retrieveFromCache) {
730                    return getPersistence()
731                                       .findByC_NotE(companyId, entryCount, start, end,
732                            orderByComparator, retrieveFromCache);
733            }
734    
735            /**
736            * Returns the first blogs stats user in the ordered set where companyId = &#63; and entryCount &ne; &#63;.
737            *
738            * @param companyId the company ID
739            * @param entryCount the entry count
740            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
741            * @return the first matching blogs stats user
742            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
743            */
744            public static BlogsStatsUser findByC_NotE_First(long companyId,
745                    int entryCount, OrderByComparator<BlogsStatsUser> orderByComparator)
746                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
747                    return getPersistence()
748                                       .findByC_NotE_First(companyId, entryCount, orderByComparator);
749            }
750    
751            /**
752            * Returns the first blogs stats user in the ordered set where companyId = &#63; and entryCount &ne; &#63;.
753            *
754            * @param companyId the company ID
755            * @param entryCount the entry count
756            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
757            * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
758            */
759            public static BlogsStatsUser fetchByC_NotE_First(long companyId,
760                    int entryCount, OrderByComparator<BlogsStatsUser> orderByComparator) {
761                    return getPersistence()
762                                       .fetchByC_NotE_First(companyId, entryCount, orderByComparator);
763            }
764    
765            /**
766            * Returns the last blogs stats user in the ordered set where companyId = &#63; and entryCount &ne; &#63;.
767            *
768            * @param companyId the company ID
769            * @param entryCount the entry count
770            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
771            * @return the last matching blogs stats user
772            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
773            */
774            public static BlogsStatsUser findByC_NotE_Last(long companyId,
775                    int entryCount, OrderByComparator<BlogsStatsUser> orderByComparator)
776                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
777                    return getPersistence()
778                                       .findByC_NotE_Last(companyId, entryCount, orderByComparator);
779            }
780    
781            /**
782            * Returns the last blogs stats user in the ordered set where companyId = &#63; and entryCount &ne; &#63;.
783            *
784            * @param companyId the company ID
785            * @param entryCount the entry count
786            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
787            * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
788            */
789            public static BlogsStatsUser fetchByC_NotE_Last(long companyId,
790                    int entryCount, OrderByComparator<BlogsStatsUser> orderByComparator) {
791                    return getPersistence()
792                                       .fetchByC_NotE_Last(companyId, entryCount, orderByComparator);
793            }
794    
795            /**
796            * Returns the blogs stats users before and after the current blogs stats user in the ordered set where companyId = &#63; and entryCount &ne; &#63;.
797            *
798            * @param statsUserId the primary key of the current blogs stats user
799            * @param companyId the company ID
800            * @param entryCount the entry count
801            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
802            * @return the previous, current, and next blogs stats user
803            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
804            */
805            public static BlogsStatsUser[] findByC_NotE_PrevAndNext(long statsUserId,
806                    long companyId, int entryCount,
807                    OrderByComparator<BlogsStatsUser> orderByComparator)
808                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
809                    return getPersistence()
810                                       .findByC_NotE_PrevAndNext(statsUserId, companyId,
811                            entryCount, orderByComparator);
812            }
813    
814            /**
815            * Removes all the blogs stats users where companyId = &#63; and entryCount &ne; &#63; from the database.
816            *
817            * @param companyId the company ID
818            * @param entryCount the entry count
819            */
820            public static void removeByC_NotE(long companyId, int entryCount) {
821                    getPersistence().removeByC_NotE(companyId, entryCount);
822            }
823    
824            /**
825            * Returns the number of blogs stats users where companyId = &#63; and entryCount &ne; &#63;.
826            *
827            * @param companyId the company ID
828            * @param entryCount the entry count
829            * @return the number of matching blogs stats users
830            */
831            public static int countByC_NotE(long companyId, int entryCount) {
832                    return getPersistence().countByC_NotE(companyId, entryCount);
833            }
834    
835            /**
836            * Returns all the blogs stats users where userId = &#63; and lastPostDate = &#63;.
837            *
838            * @param userId the user ID
839            * @param lastPostDate the last post date
840            * @return the matching blogs stats users
841            */
842            public static List<BlogsStatsUser> findByU_L(long userId,
843                    java.util.Date lastPostDate) {
844                    return getPersistence().findByU_L(userId, lastPostDate);
845            }
846    
847            /**
848            * Returns a range of all the blogs stats users where userId = &#63; and lastPostDate = &#63;.
849            *
850            * <p>
851            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>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.
852            * </p>
853            *
854            * @param userId the user ID
855            * @param lastPostDate the last post date
856            * @param start the lower bound of the range of blogs stats users
857            * @param end the upper bound of the range of blogs stats users (not inclusive)
858            * @return the range of matching blogs stats users
859            */
860            public static List<BlogsStatsUser> findByU_L(long userId,
861                    java.util.Date lastPostDate, int start, int end) {
862                    return getPersistence().findByU_L(userId, lastPostDate, start, end);
863            }
864    
865            /**
866            * Returns an ordered range of all the blogs stats users where userId = &#63; and lastPostDate = &#63;.
867            *
868            * <p>
869            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>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.
870            * </p>
871            *
872            * @param userId the user ID
873            * @param lastPostDate the last post date
874            * @param start the lower bound of the range of blogs stats users
875            * @param end the upper bound of the range of blogs stats users (not inclusive)
876            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
877            * @return the ordered range of matching blogs stats users
878            */
879            public static List<BlogsStatsUser> findByU_L(long userId,
880                    java.util.Date lastPostDate, int start, int end,
881                    OrderByComparator<BlogsStatsUser> orderByComparator) {
882                    return getPersistence()
883                                       .findByU_L(userId, lastPostDate, start, end,
884                            orderByComparator);
885            }
886    
887            /**
888            * Returns an ordered range of all the blogs stats users where userId = &#63; and lastPostDate = &#63;.
889            *
890            * <p>
891            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>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.
892            * </p>
893            *
894            * @param userId the user ID
895            * @param lastPostDate the last post date
896            * @param start the lower bound of the range of blogs stats users
897            * @param end the upper bound of the range of blogs stats users (not inclusive)
898            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
899            * @param retrieveFromCache whether to retrieve from the finder cache
900            * @return the ordered range of matching blogs stats users
901            */
902            public static List<BlogsStatsUser> findByU_L(long userId,
903                    java.util.Date lastPostDate, int start, int end,
904                    OrderByComparator<BlogsStatsUser> orderByComparator,
905                    boolean retrieveFromCache) {
906                    return getPersistence()
907                                       .findByU_L(userId, lastPostDate, start, end,
908                            orderByComparator, retrieveFromCache);
909            }
910    
911            /**
912            * Returns the first blogs stats user in the ordered set where userId = &#63; and lastPostDate = &#63;.
913            *
914            * @param userId the user ID
915            * @param lastPostDate the last post date
916            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
917            * @return the first matching blogs stats user
918            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
919            */
920            public static BlogsStatsUser findByU_L_First(long userId,
921                    java.util.Date lastPostDate,
922                    OrderByComparator<BlogsStatsUser> orderByComparator)
923                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
924                    return getPersistence()
925                                       .findByU_L_First(userId, lastPostDate, orderByComparator);
926            }
927    
928            /**
929            * Returns the first blogs stats user in the ordered set where userId = &#63; and lastPostDate = &#63;.
930            *
931            * @param userId the user ID
932            * @param lastPostDate the last post date
933            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
934            * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
935            */
936            public static BlogsStatsUser fetchByU_L_First(long userId,
937                    java.util.Date lastPostDate,
938                    OrderByComparator<BlogsStatsUser> orderByComparator) {
939                    return getPersistence()
940                                       .fetchByU_L_First(userId, lastPostDate, orderByComparator);
941            }
942    
943            /**
944            * Returns the last blogs stats user in the ordered set where userId = &#63; and lastPostDate = &#63;.
945            *
946            * @param userId the user ID
947            * @param lastPostDate the last post date
948            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
949            * @return the last matching blogs stats user
950            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
951            */
952            public static BlogsStatsUser findByU_L_Last(long userId,
953                    java.util.Date lastPostDate,
954                    OrderByComparator<BlogsStatsUser> orderByComparator)
955                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
956                    return getPersistence()
957                                       .findByU_L_Last(userId, lastPostDate, orderByComparator);
958            }
959    
960            /**
961            * Returns the last blogs stats user in the ordered set where userId = &#63; and lastPostDate = &#63;.
962            *
963            * @param userId the user ID
964            * @param lastPostDate the last post date
965            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
966            * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
967            */
968            public static BlogsStatsUser fetchByU_L_Last(long userId,
969                    java.util.Date lastPostDate,
970                    OrderByComparator<BlogsStatsUser> orderByComparator) {
971                    return getPersistence()
972                                       .fetchByU_L_Last(userId, lastPostDate, orderByComparator);
973            }
974    
975            /**
976            * Returns the blogs stats users before and after the current blogs stats user in the ordered set where userId = &#63; and lastPostDate = &#63;.
977            *
978            * @param statsUserId the primary key of the current blogs stats user
979            * @param userId the user ID
980            * @param lastPostDate the last post date
981            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
982            * @return the previous, current, and next blogs stats user
983            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
984            */
985            public static BlogsStatsUser[] findByU_L_PrevAndNext(long statsUserId,
986                    long userId, java.util.Date lastPostDate,
987                    OrderByComparator<BlogsStatsUser> orderByComparator)
988                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
989                    return getPersistence()
990                                       .findByU_L_PrevAndNext(statsUserId, userId, lastPostDate,
991                            orderByComparator);
992            }
993    
994            /**
995            * Removes all the blogs stats users where userId = &#63; and lastPostDate = &#63; from the database.
996            *
997            * @param userId the user ID
998            * @param lastPostDate the last post date
999            */
1000            public static void removeByU_L(long userId, java.util.Date lastPostDate) {
1001                    getPersistence().removeByU_L(userId, lastPostDate);
1002            }
1003    
1004            /**
1005            * Returns the number of blogs stats users where userId = &#63; and lastPostDate = &#63;.
1006            *
1007            * @param userId the user ID
1008            * @param lastPostDate the last post date
1009            * @return the number of matching blogs stats users
1010            */
1011            public static int countByU_L(long userId, java.util.Date lastPostDate) {
1012                    return getPersistence().countByU_L(userId, lastPostDate);
1013            }
1014    
1015            /**
1016            * Caches the blogs stats user in the entity cache if it is enabled.
1017            *
1018            * @param blogsStatsUser the blogs stats user
1019            */
1020            public static void cacheResult(BlogsStatsUser blogsStatsUser) {
1021                    getPersistence().cacheResult(blogsStatsUser);
1022            }
1023    
1024            /**
1025            * Caches the blogs stats users in the entity cache if it is enabled.
1026            *
1027            * @param blogsStatsUsers the blogs stats users
1028            */
1029            public static void cacheResult(List<BlogsStatsUser> blogsStatsUsers) {
1030                    getPersistence().cacheResult(blogsStatsUsers);
1031            }
1032    
1033            /**
1034            * Creates a new blogs stats user with the primary key. Does not add the blogs stats user to the database.
1035            *
1036            * @param statsUserId the primary key for the new blogs stats user
1037            * @return the new blogs stats user
1038            */
1039            public static BlogsStatsUser create(long statsUserId) {
1040                    return getPersistence().create(statsUserId);
1041            }
1042    
1043            /**
1044            * Removes the blogs stats user with the primary key from the database. Also notifies the appropriate model listeners.
1045            *
1046            * @param statsUserId the primary key of the blogs stats user
1047            * @return the blogs stats user that was removed
1048            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
1049            */
1050            public static BlogsStatsUser remove(long statsUserId)
1051                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
1052                    return getPersistence().remove(statsUserId);
1053            }
1054    
1055            public static BlogsStatsUser updateImpl(BlogsStatsUser blogsStatsUser) {
1056                    return getPersistence().updateImpl(blogsStatsUser);
1057            }
1058    
1059            /**
1060            * Returns the blogs stats user with the primary key or throws a {@link NoSuchStatsUserException} if it could not be found.
1061            *
1062            * @param statsUserId the primary key of the blogs stats user
1063            * @return the blogs stats user
1064            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
1065            */
1066            public static BlogsStatsUser findByPrimaryKey(long statsUserId)
1067                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
1068                    return getPersistence().findByPrimaryKey(statsUserId);
1069            }
1070    
1071            /**
1072            * Returns the blogs stats user with the primary key or returns <code>null</code> if it could not be found.
1073            *
1074            * @param statsUserId the primary key of the blogs stats user
1075            * @return the blogs stats user, or <code>null</code> if a blogs stats user with the primary key could not be found
1076            */
1077            public static BlogsStatsUser fetchByPrimaryKey(long statsUserId) {
1078                    return getPersistence().fetchByPrimaryKey(statsUserId);
1079            }
1080    
1081            public static java.util.Map<java.io.Serializable, BlogsStatsUser> fetchByPrimaryKeys(
1082                    java.util.Set<java.io.Serializable> primaryKeys) {
1083                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
1084            }
1085    
1086            /**
1087            * Returns all the blogs stats users.
1088            *
1089            * @return the blogs stats users
1090            */
1091            public static List<BlogsStatsUser> findAll() {
1092                    return getPersistence().findAll();
1093            }
1094    
1095            /**
1096            * Returns a range of all the blogs stats users.
1097            *
1098            * <p>
1099            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>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.
1100            * </p>
1101            *
1102            * @param start the lower bound of the range of blogs stats users
1103            * @param end the upper bound of the range of blogs stats users (not inclusive)
1104            * @return the range of blogs stats users
1105            */
1106            public static List<BlogsStatsUser> findAll(int start, int end) {
1107                    return getPersistence().findAll(start, end);
1108            }
1109    
1110            /**
1111            * Returns an ordered range of all the blogs stats users.
1112            *
1113            * <p>
1114            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1115            * </p>
1116            *
1117            * @param start the lower bound of the range of blogs stats users
1118            * @param end the upper bound of the range of blogs stats users (not inclusive)
1119            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1120            * @return the ordered range of blogs stats users
1121            */
1122            public static List<BlogsStatsUser> findAll(int start, int end,
1123                    OrderByComparator<BlogsStatsUser> orderByComparator) {
1124                    return getPersistence().findAll(start, end, orderByComparator);
1125            }
1126    
1127            /**
1128            * Returns an ordered range of all the blogs stats users.
1129            *
1130            * <p>
1131            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>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.
1132            * </p>
1133            *
1134            * @param start the lower bound of the range of blogs stats users
1135            * @param end the upper bound of the range of blogs stats users (not inclusive)
1136            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1137            * @param retrieveFromCache whether to retrieve from the finder cache
1138            * @return the ordered range of blogs stats users
1139            */
1140            public static List<BlogsStatsUser> findAll(int start, int end,
1141                    OrderByComparator<BlogsStatsUser> orderByComparator,
1142                    boolean retrieveFromCache) {
1143                    return getPersistence()
1144                                       .findAll(start, end, orderByComparator, retrieveFromCache);
1145            }
1146    
1147            /**
1148            * Removes all the blogs stats users from the database.
1149            */
1150            public static void removeAll() {
1151                    getPersistence().removeAll();
1152            }
1153    
1154            /**
1155            * Returns the number of blogs stats users.
1156            *
1157            * @return the number of blogs stats users
1158            */
1159            public static int countAll() {
1160                    return getPersistence().countAll();
1161            }
1162    
1163            public static BlogsStatsUserPersistence getPersistence() {
1164                    if (_persistence == null) {
1165                            _persistence = (BlogsStatsUserPersistence)PortalBeanLocatorUtil.locate(BlogsStatsUserPersistence.class.getName());
1166    
1167                            ReferenceRegistry.registerReference(BlogsStatsUserUtil.class,
1168                                    "_persistence");
1169                    }
1170    
1171                    return _persistence;
1172            }
1173    
1174            private static BlogsStatsUserPersistence _persistence;
1175    }