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.Date;
028    import java.util.List;
029    
030    /**
031     * 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.
032     *
033     * <p>
034     * Caching information and settings can be found in <code>portal.properties</code>
035     * </p>
036     *
037     * @author Brian Wing Shun Chan
038     * @see BlogsStatsUserPersistence
039     * @see com.liferay.portlet.blogs.service.persistence.impl.BlogsStatsUserPersistenceImpl
040     * @generated
041     */
042    @ProviderType
043    public class BlogsStatsUserUtil {
044            /*
045             * NOTE FOR DEVELOPERS:
046             *
047             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
048             */
049    
050            /**
051             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
052             */
053            public static void clearCache() {
054                    getPersistence().clearCache();
055            }
056    
057            /**
058             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
059             */
060            public static void clearCache(BlogsStatsUser blogsStatsUser) {
061                    getPersistence().clearCache(blogsStatsUser);
062            }
063    
064            /**
065             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
066             */
067            public static long countWithDynamicQuery(DynamicQuery dynamicQuery) {
068                    return getPersistence().countWithDynamicQuery(dynamicQuery);
069            }
070    
071            /**
072             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
073             */
074            public static List<BlogsStatsUser> findWithDynamicQuery(
075                    DynamicQuery dynamicQuery) {
076                    return getPersistence().findWithDynamicQuery(dynamicQuery);
077            }
078    
079            /**
080             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
081             */
082            public static List<BlogsStatsUser> findWithDynamicQuery(
083                    DynamicQuery dynamicQuery, int start, int end) {
084                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
085            }
086    
087            /**
088             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
089             */
090            public static List<BlogsStatsUser> findWithDynamicQuery(
091                    DynamicQuery dynamicQuery, int start, int end,
092                    OrderByComparator<BlogsStatsUser> orderByComparator) {
093                    return getPersistence()
094                                       .findWithDynamicQuery(dynamicQuery, start, end,
095                            orderByComparator);
096            }
097    
098            /**
099             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
100             */
101            public static BlogsStatsUser update(BlogsStatsUser blogsStatsUser) {
102                    return getPersistence().update(blogsStatsUser);
103            }
104    
105            /**
106             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
107             */
108            public static BlogsStatsUser update(BlogsStatsUser blogsStatsUser,
109                    ServiceContext serviceContext) {
110                    return getPersistence().update(blogsStatsUser, serviceContext);
111            }
112    
113            /**
114            * Returns all the blogs stats users where groupId = &#63;.
115            *
116            * @param groupId the group ID
117            * @return the matching blogs stats users
118            */
119            public static List<BlogsStatsUser> findByGroupId(long groupId) {
120                    return getPersistence().findByGroupId(groupId);
121            }
122    
123            /**
124            * Returns a range of all the blogs stats users where groupId = &#63;.
125            *
126            * <p>
127            * 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.
128            * </p>
129            *
130            * @param groupId the group ID
131            * @param start the lower bound of the range of blogs stats users
132            * @param end the upper bound of the range of blogs stats users (not inclusive)
133            * @return the range of matching blogs stats users
134            */
135            public static List<BlogsStatsUser> findByGroupId(long groupId, int start,
136                    int end) {
137                    return getPersistence().findByGroupId(groupId, start, end);
138            }
139    
140            /**
141            * Returns an ordered range of all the blogs stats users where groupId = &#63;.
142            *
143            * <p>
144            * 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.
145            * </p>
146            *
147            * @param groupId the group ID
148            * @param start the lower bound of the range of blogs stats users
149            * @param end the upper bound of the range of blogs stats users (not inclusive)
150            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
151            * @return the ordered range of matching blogs stats users
152            */
153            public static List<BlogsStatsUser> findByGroupId(long groupId, int start,
154                    int end, OrderByComparator<BlogsStatsUser> orderByComparator) {
155                    return getPersistence()
156                                       .findByGroupId(groupId, start, end, orderByComparator);
157            }
158    
159            /**
160            * Returns an ordered range of all the blogs stats users where groupId = &#63;.
161            *
162            * <p>
163            * 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.
164            * </p>
165            *
166            * @param groupId the group ID
167            * @param start the lower bound of the range of blogs stats users
168            * @param end the upper bound of the range of blogs stats users (not inclusive)
169            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
170            * @param retrieveFromCache whether to retrieve from the finder cache
171            * @return the ordered range of matching blogs stats users
172            */
173            public static List<BlogsStatsUser> findByGroupId(long groupId, int start,
174                    int end, OrderByComparator<BlogsStatsUser> orderByComparator,
175                    boolean retrieveFromCache) {
176                    return getPersistence()
177                                       .findByGroupId(groupId, start, end, orderByComparator,
178                            retrieveFromCache);
179            }
180    
181            /**
182            * Returns the first blogs stats user in the ordered set where groupId = &#63;.
183            *
184            * @param groupId the group ID
185            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
186            * @return the first matching blogs stats user
187            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
188            */
189            public static BlogsStatsUser findByGroupId_First(long groupId,
190                    OrderByComparator<BlogsStatsUser> orderByComparator)
191                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
192                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
193            }
194    
195            /**
196            * Returns the first blogs stats user in the ordered set where groupId = &#63;.
197            *
198            * @param groupId the group ID
199            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
200            * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
201            */
202            public static BlogsStatsUser fetchByGroupId_First(long groupId,
203                    OrderByComparator<BlogsStatsUser> orderByComparator) {
204                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
205            }
206    
207            /**
208            * Returns the last blogs stats user in the ordered set where groupId = &#63;.
209            *
210            * @param groupId the group ID
211            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
212            * @return the last matching blogs stats user
213            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
214            */
215            public static BlogsStatsUser findByGroupId_Last(long groupId,
216                    OrderByComparator<BlogsStatsUser> orderByComparator)
217                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
218                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
219            }
220    
221            /**
222            * Returns the last blogs stats user in the ordered set where groupId = &#63;.
223            *
224            * @param groupId the group ID
225            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
226            * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
227            */
228            public static BlogsStatsUser fetchByGroupId_Last(long groupId,
229                    OrderByComparator<BlogsStatsUser> orderByComparator) {
230                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
231            }
232    
233            /**
234            * Returns the blogs stats users before and after the current blogs stats user in the ordered set where groupId = &#63;.
235            *
236            * @param statsUserId the primary key of the current blogs stats user
237            * @param groupId the group ID
238            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
239            * @return the previous, current, and next blogs stats user
240            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
241            */
242            public static BlogsStatsUser[] findByGroupId_PrevAndNext(long statsUserId,
243                    long groupId, OrderByComparator<BlogsStatsUser> orderByComparator)
244                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
245                    return getPersistence()
246                                       .findByGroupId_PrevAndNext(statsUserId, groupId,
247                            orderByComparator);
248            }
249    
250            /**
251            * Removes all the blogs stats users where groupId = &#63; from the database.
252            *
253            * @param groupId the group ID
254            */
255            public static void removeByGroupId(long groupId) {
256                    getPersistence().removeByGroupId(groupId);
257            }
258    
259            /**
260            * Returns the number of blogs stats users where groupId = &#63;.
261            *
262            * @param groupId the group ID
263            * @return the number of matching blogs stats users
264            */
265            public static int countByGroupId(long groupId) {
266                    return getPersistence().countByGroupId(groupId);
267            }
268    
269            /**
270            * Returns all the blogs stats users where userId = &#63;.
271            *
272            * @param userId the user ID
273            * @return the matching blogs stats users
274            */
275            public static List<BlogsStatsUser> findByUserId(long userId) {
276                    return getPersistence().findByUserId(userId);
277            }
278    
279            /**
280            * Returns a range of all the blogs stats users where userId = &#63;.
281            *
282            * <p>
283            * 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.
284            * </p>
285            *
286            * @param userId the user ID
287            * @param start the lower bound of the range of blogs stats users
288            * @param end the upper bound of the range of blogs stats users (not inclusive)
289            * @return the range of matching blogs stats users
290            */
291            public static List<BlogsStatsUser> findByUserId(long userId, int start,
292                    int end) {
293                    return getPersistence().findByUserId(userId, start, end);
294            }
295    
296            /**
297            * Returns an ordered range of all the blogs stats users where userId = &#63;.
298            *
299            * <p>
300            * 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.
301            * </p>
302            *
303            * @param userId the user ID
304            * @param start the lower bound of the range of blogs stats users
305            * @param end the upper bound of the range of blogs stats users (not inclusive)
306            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
307            * @return the ordered range of matching blogs stats users
308            */
309            public static List<BlogsStatsUser> findByUserId(long userId, int start,
310                    int end, OrderByComparator<BlogsStatsUser> orderByComparator) {
311                    return getPersistence()
312                                       .findByUserId(userId, start, end, orderByComparator);
313            }
314    
315            /**
316            * Returns an ordered range of all the blogs stats users where userId = &#63;.
317            *
318            * <p>
319            * 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.
320            * </p>
321            *
322            * @param userId the user ID
323            * @param start the lower bound of the range of blogs stats users
324            * @param end the upper bound of the range of blogs stats users (not inclusive)
325            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
326            * @param retrieveFromCache whether to retrieve from the finder cache
327            * @return the ordered range of matching blogs stats users
328            */
329            public static List<BlogsStatsUser> findByUserId(long userId, int start,
330                    int end, OrderByComparator<BlogsStatsUser> orderByComparator,
331                    boolean retrieveFromCache) {
332                    return getPersistence()
333                                       .findByUserId(userId, start, end, orderByComparator,
334                            retrieveFromCache);
335            }
336    
337            /**
338            * Returns the first blogs stats user in the ordered set where userId = &#63;.
339            *
340            * @param userId the user ID
341            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
342            * @return the first matching blogs stats user
343            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
344            */
345            public static BlogsStatsUser findByUserId_First(long userId,
346                    OrderByComparator<BlogsStatsUser> orderByComparator)
347                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
348                    return getPersistence().findByUserId_First(userId, orderByComparator);
349            }
350    
351            /**
352            * Returns the first blogs stats user in the ordered set where userId = &#63;.
353            *
354            * @param userId the user ID
355            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
356            * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
357            */
358            public static BlogsStatsUser fetchByUserId_First(long userId,
359                    OrderByComparator<BlogsStatsUser> orderByComparator) {
360                    return getPersistence().fetchByUserId_First(userId, orderByComparator);
361            }
362    
363            /**
364            * Returns the last blogs stats user in the ordered set where userId = &#63;.
365            *
366            * @param userId the user ID
367            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
368            * @return the last matching blogs stats user
369            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
370            */
371            public static BlogsStatsUser findByUserId_Last(long userId,
372                    OrderByComparator<BlogsStatsUser> orderByComparator)
373                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
374                    return getPersistence().findByUserId_Last(userId, orderByComparator);
375            }
376    
377            /**
378            * Returns the last blogs stats user in the ordered set where userId = &#63;.
379            *
380            * @param userId the user ID
381            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
382            * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
383            */
384            public static BlogsStatsUser fetchByUserId_Last(long userId,
385                    OrderByComparator<BlogsStatsUser> orderByComparator) {
386                    return getPersistence().fetchByUserId_Last(userId, orderByComparator);
387            }
388    
389            /**
390            * Returns the blogs stats users before and after the current blogs stats user in the ordered set where userId = &#63;.
391            *
392            * @param statsUserId the primary key of the current blogs stats user
393            * @param userId the user ID
394            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
395            * @return the previous, current, and next blogs stats user
396            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
397            */
398            public static BlogsStatsUser[] findByUserId_PrevAndNext(long statsUserId,
399                    long userId, OrderByComparator<BlogsStatsUser> orderByComparator)
400                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
401                    return getPersistence()
402                                       .findByUserId_PrevAndNext(statsUserId, userId,
403                            orderByComparator);
404            }
405    
406            /**
407            * Removes all the blogs stats users where userId = &#63; from the database.
408            *
409            * @param userId the user ID
410            */
411            public static void removeByUserId(long userId) {
412                    getPersistence().removeByUserId(userId);
413            }
414    
415            /**
416            * Returns the number of blogs stats users where userId = &#63;.
417            *
418            * @param userId the user ID
419            * @return the number of matching blogs stats users
420            */
421            public static int countByUserId(long userId) {
422                    return getPersistence().countByUserId(userId);
423            }
424    
425            /**
426            * Returns the blogs stats user where groupId = &#63; and userId = &#63; or throws a {@link NoSuchStatsUserException} if it could not be found.
427            *
428            * @param groupId the group ID
429            * @param userId the user ID
430            * @return the matching blogs stats user
431            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
432            */
433            public static BlogsStatsUser findByG_U(long groupId, long userId)
434                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
435                    return getPersistence().findByG_U(groupId, userId);
436            }
437    
438            /**
439            * 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.
440            *
441            * @param groupId the group ID
442            * @param userId the user ID
443            * @return the matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
444            */
445            public static BlogsStatsUser fetchByG_U(long groupId, long userId) {
446                    return getPersistence().fetchByG_U(groupId, userId);
447            }
448    
449            /**
450            * 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.
451            *
452            * @param groupId the group ID
453            * @param userId the user ID
454            * @param retrieveFromCache whether to retrieve from the finder cache
455            * @return the matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
456            */
457            public static BlogsStatsUser fetchByG_U(long groupId, long userId,
458                    boolean retrieveFromCache) {
459                    return getPersistence().fetchByG_U(groupId, userId, retrieveFromCache);
460            }
461    
462            /**
463            * Removes the blogs stats user where groupId = &#63; and userId = &#63; from the database.
464            *
465            * @param groupId the group ID
466            * @param userId the user ID
467            * @return the blogs stats user that was removed
468            */
469            public static BlogsStatsUser removeByG_U(long groupId, long userId)
470                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
471                    return getPersistence().removeByG_U(groupId, userId);
472            }
473    
474            /**
475            * Returns the number of blogs stats users where groupId = &#63; and userId = &#63;.
476            *
477            * @param groupId the group ID
478            * @param userId the user ID
479            * @return the number of matching blogs stats users
480            */
481            public static int countByG_U(long groupId, long userId) {
482                    return getPersistence().countByG_U(groupId, userId);
483            }
484    
485            /**
486            * Returns all the blogs stats users where groupId = &#63; and entryCount &ne; &#63;.
487            *
488            * @param groupId the group ID
489            * @param entryCount the entry count
490            * @return the matching blogs stats users
491            */
492            public static List<BlogsStatsUser> findByG_NotE(long groupId, int entryCount) {
493                    return getPersistence().findByG_NotE(groupId, entryCount);
494            }
495    
496            /**
497            * Returns a range of all the blogs stats users where groupId = &#63; and entryCount &ne; &#63;.
498            *
499            * <p>
500            * 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.
501            * </p>
502            *
503            * @param groupId the group ID
504            * @param entryCount the entry count
505            * @param start the lower bound of the range of blogs stats users
506            * @param end the upper bound of the range of blogs stats users (not inclusive)
507            * @return the range of matching blogs stats users
508            */
509            public static List<BlogsStatsUser> findByG_NotE(long groupId,
510                    int entryCount, int start, int end) {
511                    return getPersistence().findByG_NotE(groupId, entryCount, start, end);
512            }
513    
514            /**
515            * Returns an ordered range of all the blogs stats users where groupId = &#63; and entryCount &ne; &#63;.
516            *
517            * <p>
518            * 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.
519            * </p>
520            *
521            * @param groupId the group ID
522            * @param entryCount the entry count
523            * @param start the lower bound of the range of blogs stats users
524            * @param end the upper bound of the range of blogs stats users (not inclusive)
525            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
526            * @return the ordered range of matching blogs stats users
527            */
528            public static List<BlogsStatsUser> findByG_NotE(long groupId,
529                    int entryCount, int start, int end,
530                    OrderByComparator<BlogsStatsUser> orderByComparator) {
531                    return getPersistence()
532                                       .findByG_NotE(groupId, entryCount, start, end,
533                            orderByComparator);
534            }
535    
536            /**
537            * Returns an ordered range of all the blogs stats users where groupId = &#63; and entryCount &ne; &#63;.
538            *
539            * <p>
540            * 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.
541            * </p>
542            *
543            * @param groupId the group ID
544            * @param entryCount the entry count
545            * @param start the lower bound of the range of blogs stats users
546            * @param end the upper bound of the range of blogs stats users (not inclusive)
547            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
548            * @param retrieveFromCache whether to retrieve from the finder cache
549            * @return the ordered range of matching blogs stats users
550            */
551            public static List<BlogsStatsUser> findByG_NotE(long groupId,
552                    int entryCount, int start, int end,
553                    OrderByComparator<BlogsStatsUser> orderByComparator,
554                    boolean retrieveFromCache) {
555                    return getPersistence()
556                                       .findByG_NotE(groupId, entryCount, start, end,
557                            orderByComparator, retrieveFromCache);
558            }
559    
560            /**
561            * Returns the first blogs stats user in the ordered set where groupId = &#63; and entryCount &ne; &#63;.
562            *
563            * @param groupId the group ID
564            * @param entryCount the entry count
565            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
566            * @return the first matching blogs stats user
567            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
568            */
569            public static BlogsStatsUser findByG_NotE_First(long groupId,
570                    int entryCount, OrderByComparator<BlogsStatsUser> orderByComparator)
571                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
572                    return getPersistence()
573                                       .findByG_NotE_First(groupId, entryCount, orderByComparator);
574            }
575    
576            /**
577            * Returns the first blogs stats user in the ordered set where groupId = &#63; and entryCount &ne; &#63;.
578            *
579            * @param groupId the group ID
580            * @param entryCount the entry count
581            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
582            * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
583            */
584            public static BlogsStatsUser fetchByG_NotE_First(long groupId,
585                    int entryCount, OrderByComparator<BlogsStatsUser> orderByComparator) {
586                    return getPersistence()
587                                       .fetchByG_NotE_First(groupId, entryCount, orderByComparator);
588            }
589    
590            /**
591            * Returns the last blogs stats user in the ordered set where groupId = &#63; and entryCount &ne; &#63;.
592            *
593            * @param groupId the group ID
594            * @param entryCount the entry count
595            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
596            * @return the last matching blogs stats user
597            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
598            */
599            public static BlogsStatsUser findByG_NotE_Last(long groupId,
600                    int entryCount, OrderByComparator<BlogsStatsUser> orderByComparator)
601                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
602                    return getPersistence()
603                                       .findByG_NotE_Last(groupId, entryCount, orderByComparator);
604            }
605    
606            /**
607            * Returns the last blogs stats user in the ordered set where groupId = &#63; and entryCount &ne; &#63;.
608            *
609            * @param groupId the group ID
610            * @param entryCount the entry count
611            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
612            * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
613            */
614            public static BlogsStatsUser fetchByG_NotE_Last(long groupId,
615                    int entryCount, OrderByComparator<BlogsStatsUser> orderByComparator) {
616                    return getPersistence()
617                                       .fetchByG_NotE_Last(groupId, entryCount, orderByComparator);
618            }
619    
620            /**
621            * Returns the blogs stats users before and after the current blogs stats user in the ordered set where groupId = &#63; and entryCount &ne; &#63;.
622            *
623            * @param statsUserId the primary key of the current blogs stats user
624            * @param groupId the group ID
625            * @param entryCount the entry count
626            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
627            * @return the previous, current, and next blogs stats user
628            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
629            */
630            public static BlogsStatsUser[] findByG_NotE_PrevAndNext(long statsUserId,
631                    long groupId, int entryCount,
632                    OrderByComparator<BlogsStatsUser> orderByComparator)
633                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
634                    return getPersistence()
635                                       .findByG_NotE_PrevAndNext(statsUserId, groupId, entryCount,
636                            orderByComparator);
637            }
638    
639            /**
640            * Removes all the blogs stats users where groupId = &#63; and entryCount &ne; &#63; from the database.
641            *
642            * @param groupId the group ID
643            * @param entryCount the entry count
644            */
645            public static void removeByG_NotE(long groupId, int entryCount) {
646                    getPersistence().removeByG_NotE(groupId, entryCount);
647            }
648    
649            /**
650            * Returns the number of blogs stats users where groupId = &#63; and entryCount &ne; &#63;.
651            *
652            * @param groupId the group ID
653            * @param entryCount the entry count
654            * @return the number of matching blogs stats users
655            */
656            public static int countByG_NotE(long groupId, int entryCount) {
657                    return getPersistence().countByG_NotE(groupId, entryCount);
658            }
659    
660            /**
661            * Returns all the blogs stats users where companyId = &#63; and entryCount &ne; &#63;.
662            *
663            * @param companyId the company ID
664            * @param entryCount the entry count
665            * @return the matching blogs stats users
666            */
667            public static List<BlogsStatsUser> findByC_NotE(long companyId,
668                    int entryCount) {
669                    return getPersistence().findByC_NotE(companyId, entryCount);
670            }
671    
672            /**
673            * Returns a range of all the blogs stats users where companyId = &#63; and entryCount &ne; &#63;.
674            *
675            * <p>
676            * 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.
677            * </p>
678            *
679            * @param companyId the company ID
680            * @param entryCount the entry count
681            * @param start the lower bound of the range of blogs stats users
682            * @param end the upper bound of the range of blogs stats users (not inclusive)
683            * @return the range of matching blogs stats users
684            */
685            public static List<BlogsStatsUser> findByC_NotE(long companyId,
686                    int entryCount, int start, int end) {
687                    return getPersistence().findByC_NotE(companyId, entryCount, start, end);
688            }
689    
690            /**
691            * Returns an ordered range of all the blogs stats users where companyId = &#63; and entryCount &ne; &#63;.
692            *
693            * <p>
694            * 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.
695            * </p>
696            *
697            * @param companyId the company ID
698            * @param entryCount the entry count
699            * @param start the lower bound of the range of blogs stats users
700            * @param end the upper bound of the range of blogs stats users (not inclusive)
701            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
702            * @return the ordered range of matching blogs stats users
703            */
704            public static List<BlogsStatsUser> findByC_NotE(long companyId,
705                    int entryCount, int start, int end,
706                    OrderByComparator<BlogsStatsUser> orderByComparator) {
707                    return getPersistence()
708                                       .findByC_NotE(companyId, entryCount, start, end,
709                            orderByComparator);
710            }
711    
712            /**
713            * Returns an ordered range of all the blogs stats users where companyId = &#63; and entryCount &ne; &#63;.
714            *
715            * <p>
716            * 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.
717            * </p>
718            *
719            * @param companyId the company ID
720            * @param entryCount the entry count
721            * @param start the lower bound of the range of blogs stats users
722            * @param end the upper bound of the range of blogs stats users (not inclusive)
723            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
724            * @param retrieveFromCache whether to retrieve from the finder cache
725            * @return the ordered range of matching blogs stats users
726            */
727            public static List<BlogsStatsUser> findByC_NotE(long companyId,
728                    int entryCount, int start, int end,
729                    OrderByComparator<BlogsStatsUser> orderByComparator,
730                    boolean retrieveFromCache) {
731                    return getPersistence()
732                                       .findByC_NotE(companyId, entryCount, start, end,
733                            orderByComparator, retrieveFromCache);
734            }
735    
736            /**
737            * Returns the first blogs stats user in the ordered set where companyId = &#63; and entryCount &ne; &#63;.
738            *
739            * @param companyId the company ID
740            * @param entryCount the entry count
741            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
742            * @return the first matching blogs stats user
743            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
744            */
745            public static BlogsStatsUser findByC_NotE_First(long companyId,
746                    int entryCount, OrderByComparator<BlogsStatsUser> orderByComparator)
747                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
748                    return getPersistence()
749                                       .findByC_NotE_First(companyId, entryCount, orderByComparator);
750            }
751    
752            /**
753            * Returns the first blogs stats user in the ordered set where companyId = &#63; and entryCount &ne; &#63;.
754            *
755            * @param companyId the company ID
756            * @param entryCount the entry count
757            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
758            * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
759            */
760            public static BlogsStatsUser fetchByC_NotE_First(long companyId,
761                    int entryCount, OrderByComparator<BlogsStatsUser> orderByComparator) {
762                    return getPersistence()
763                                       .fetchByC_NotE_First(companyId, entryCount, orderByComparator);
764            }
765    
766            /**
767            * Returns the last blogs stats user in the ordered set where companyId = &#63; and entryCount &ne; &#63;.
768            *
769            * @param companyId the company ID
770            * @param entryCount the entry count
771            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
772            * @return the last matching blogs stats user
773            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
774            */
775            public static BlogsStatsUser findByC_NotE_Last(long companyId,
776                    int entryCount, OrderByComparator<BlogsStatsUser> orderByComparator)
777                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
778                    return getPersistence()
779                                       .findByC_NotE_Last(companyId, entryCount, orderByComparator);
780            }
781    
782            /**
783            * Returns the last blogs stats user in the ordered set where companyId = &#63; and entryCount &ne; &#63;.
784            *
785            * @param companyId the company ID
786            * @param entryCount the entry count
787            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
788            * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
789            */
790            public static BlogsStatsUser fetchByC_NotE_Last(long companyId,
791                    int entryCount, OrderByComparator<BlogsStatsUser> orderByComparator) {
792                    return getPersistence()
793                                       .fetchByC_NotE_Last(companyId, entryCount, orderByComparator);
794            }
795    
796            /**
797            * Returns the blogs stats users before and after the current blogs stats user in the ordered set where companyId = &#63; and entryCount &ne; &#63;.
798            *
799            * @param statsUserId the primary key of the current blogs stats user
800            * @param companyId the company ID
801            * @param entryCount the entry count
802            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
803            * @return the previous, current, and next blogs stats user
804            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
805            */
806            public static BlogsStatsUser[] findByC_NotE_PrevAndNext(long statsUserId,
807                    long companyId, int entryCount,
808                    OrderByComparator<BlogsStatsUser> orderByComparator)
809                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
810                    return getPersistence()
811                                       .findByC_NotE_PrevAndNext(statsUserId, companyId,
812                            entryCount, orderByComparator);
813            }
814    
815            /**
816            * Removes all the blogs stats users where companyId = &#63; and entryCount &ne; &#63; from the database.
817            *
818            * @param companyId the company ID
819            * @param entryCount the entry count
820            */
821            public static void removeByC_NotE(long companyId, int entryCount) {
822                    getPersistence().removeByC_NotE(companyId, entryCount);
823            }
824    
825            /**
826            * Returns the number of blogs stats users where companyId = &#63; and entryCount &ne; &#63;.
827            *
828            * @param companyId the company ID
829            * @param entryCount the entry count
830            * @return the number of matching blogs stats users
831            */
832            public static int countByC_NotE(long companyId, int entryCount) {
833                    return getPersistence().countByC_NotE(companyId, entryCount);
834            }
835    
836            /**
837            * Returns all the blogs stats users where userId = &#63; and lastPostDate = &#63;.
838            *
839            * @param userId the user ID
840            * @param lastPostDate the last post date
841            * @return the matching blogs stats users
842            */
843            public static List<BlogsStatsUser> findByU_L(long userId, 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                    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                    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                    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                    Date lastPostDate, OrderByComparator<BlogsStatsUser> orderByComparator)
922                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
923                    return getPersistence()
924                                       .findByU_L_First(userId, lastPostDate, orderByComparator);
925            }
926    
927            /**
928            * Returns the first blogs stats user in the ordered set where userId = &#63; and lastPostDate = &#63;.
929            *
930            * @param userId the user ID
931            * @param lastPostDate the last post date
932            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
933            * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
934            */
935            public static BlogsStatsUser fetchByU_L_First(long userId,
936                    Date lastPostDate, OrderByComparator<BlogsStatsUser> orderByComparator) {
937                    return getPersistence()
938                                       .fetchByU_L_First(userId, lastPostDate, orderByComparator);
939            }
940    
941            /**
942            * Returns the last blogs stats user in the ordered set where userId = &#63; and lastPostDate = &#63;.
943            *
944            * @param userId the user ID
945            * @param lastPostDate the last post date
946            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
947            * @return the last matching blogs stats user
948            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
949            */
950            public static BlogsStatsUser findByU_L_Last(long userId, Date lastPostDate,
951                    OrderByComparator<BlogsStatsUser> orderByComparator)
952                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
953                    return getPersistence()
954                                       .findByU_L_Last(userId, lastPostDate, orderByComparator);
955            }
956    
957            /**
958            * Returns the last blogs stats user in the ordered set where userId = &#63; and lastPostDate = &#63;.
959            *
960            * @param userId the user ID
961            * @param lastPostDate the last post date
962            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
963            * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
964            */
965            public static BlogsStatsUser fetchByU_L_Last(long userId,
966                    Date lastPostDate, OrderByComparator<BlogsStatsUser> orderByComparator) {
967                    return getPersistence()
968                                       .fetchByU_L_Last(userId, lastPostDate, orderByComparator);
969            }
970    
971            /**
972            * Returns the blogs stats users before and after the current blogs stats user in the ordered set where userId = &#63; and lastPostDate = &#63;.
973            *
974            * @param statsUserId the primary key of the current blogs stats user
975            * @param userId the user ID
976            * @param lastPostDate the last post date
977            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
978            * @return the previous, current, and next blogs stats user
979            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
980            */
981            public static BlogsStatsUser[] findByU_L_PrevAndNext(long statsUserId,
982                    long userId, Date lastPostDate,
983                    OrderByComparator<BlogsStatsUser> orderByComparator)
984                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
985                    return getPersistence()
986                                       .findByU_L_PrevAndNext(statsUserId, userId, lastPostDate,
987                            orderByComparator);
988            }
989    
990            /**
991            * Removes all the blogs stats users where userId = &#63; and lastPostDate = &#63; from the database.
992            *
993            * @param userId the user ID
994            * @param lastPostDate the last post date
995            */
996            public static void removeByU_L(long userId, Date lastPostDate) {
997                    getPersistence().removeByU_L(userId, lastPostDate);
998            }
999    
1000            /**
1001            * Returns the number of blogs stats users where userId = &#63; and lastPostDate = &#63;.
1002            *
1003            * @param userId the user ID
1004            * @param lastPostDate the last post date
1005            * @return the number of matching blogs stats users
1006            */
1007            public static int countByU_L(long userId, Date lastPostDate) {
1008                    return getPersistence().countByU_L(userId, lastPostDate);
1009            }
1010    
1011            /**
1012            * Caches the blogs stats user in the entity cache if it is enabled.
1013            *
1014            * @param blogsStatsUser the blogs stats user
1015            */
1016            public static void cacheResult(BlogsStatsUser blogsStatsUser) {
1017                    getPersistence().cacheResult(blogsStatsUser);
1018            }
1019    
1020            /**
1021            * Caches the blogs stats users in the entity cache if it is enabled.
1022            *
1023            * @param blogsStatsUsers the blogs stats users
1024            */
1025            public static void cacheResult(List<BlogsStatsUser> blogsStatsUsers) {
1026                    getPersistence().cacheResult(blogsStatsUsers);
1027            }
1028    
1029            /**
1030            * Creates a new blogs stats user with the primary key. Does not add the blogs stats user to the database.
1031            *
1032            * @param statsUserId the primary key for the new blogs stats user
1033            * @return the new blogs stats user
1034            */
1035            public static BlogsStatsUser create(long statsUserId) {
1036                    return getPersistence().create(statsUserId);
1037            }
1038    
1039            /**
1040            * Removes the blogs stats user with the primary key from the database. Also notifies the appropriate model listeners.
1041            *
1042            * @param statsUserId the primary key of the blogs stats user
1043            * @return the blogs stats user that was removed
1044            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
1045            */
1046            public static BlogsStatsUser remove(long statsUserId)
1047                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
1048                    return getPersistence().remove(statsUserId);
1049            }
1050    
1051            public static BlogsStatsUser updateImpl(BlogsStatsUser blogsStatsUser) {
1052                    return getPersistence().updateImpl(blogsStatsUser);
1053            }
1054    
1055            /**
1056            * Returns the blogs stats user with the primary key or throws a {@link NoSuchStatsUserException} if it could not be found.
1057            *
1058            * @param statsUserId the primary key of the blogs stats user
1059            * @return the blogs stats user
1060            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
1061            */
1062            public static BlogsStatsUser findByPrimaryKey(long statsUserId)
1063                    throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException {
1064                    return getPersistence().findByPrimaryKey(statsUserId);
1065            }
1066    
1067            /**
1068            * Returns the blogs stats user with the primary key or returns <code>null</code> if it could not be found.
1069            *
1070            * @param statsUserId the primary key of the blogs stats user
1071            * @return the blogs stats user, or <code>null</code> if a blogs stats user with the primary key could not be found
1072            */
1073            public static BlogsStatsUser fetchByPrimaryKey(long statsUserId) {
1074                    return getPersistence().fetchByPrimaryKey(statsUserId);
1075            }
1076    
1077            public static java.util.Map<java.io.Serializable, BlogsStatsUser> fetchByPrimaryKeys(
1078                    java.util.Set<java.io.Serializable> primaryKeys) {
1079                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
1080            }
1081    
1082            /**
1083            * Returns all the blogs stats users.
1084            *
1085            * @return the blogs stats users
1086            */
1087            public static List<BlogsStatsUser> findAll() {
1088                    return getPersistence().findAll();
1089            }
1090    
1091            /**
1092            * Returns a range of all the blogs stats users.
1093            *
1094            * <p>
1095            * 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.
1096            * </p>
1097            *
1098            * @param start the lower bound of the range of blogs stats users
1099            * @param end the upper bound of the range of blogs stats users (not inclusive)
1100            * @return the range of blogs stats users
1101            */
1102            public static List<BlogsStatsUser> findAll(int start, int end) {
1103                    return getPersistence().findAll(start, end);
1104            }
1105    
1106            /**
1107            * Returns an ordered range of all the blogs stats users.
1108            *
1109            * <p>
1110            * 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.
1111            * </p>
1112            *
1113            * @param start the lower bound of the range of blogs stats users
1114            * @param end the upper bound of the range of blogs stats users (not inclusive)
1115            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1116            * @return the ordered range of blogs stats users
1117            */
1118            public static List<BlogsStatsUser> findAll(int start, int end,
1119                    OrderByComparator<BlogsStatsUser> orderByComparator) {
1120                    return getPersistence().findAll(start, end, orderByComparator);
1121            }
1122    
1123            /**
1124            * Returns an ordered range of all the blogs stats users.
1125            *
1126            * <p>
1127            * 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.
1128            * </p>
1129            *
1130            * @param start the lower bound of the range of blogs stats users
1131            * @param end the upper bound of the range of blogs stats users (not inclusive)
1132            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1133            * @param retrieveFromCache whether to retrieve from the finder cache
1134            * @return the ordered range of blogs stats users
1135            */
1136            public static List<BlogsStatsUser> findAll(int start, int end,
1137                    OrderByComparator<BlogsStatsUser> orderByComparator,
1138                    boolean retrieveFromCache) {
1139                    return getPersistence()
1140                                       .findAll(start, end, orderByComparator, retrieveFromCache);
1141            }
1142    
1143            /**
1144            * Removes all the blogs stats users from the database.
1145            */
1146            public static void removeAll() {
1147                    getPersistence().removeAll();
1148            }
1149    
1150            /**
1151            * Returns the number of blogs stats users.
1152            *
1153            * @return the number of blogs stats users
1154            */
1155            public static int countAll() {
1156                    return getPersistence().countAll();
1157            }
1158    
1159            public static BlogsStatsUserPersistence getPersistence() {
1160                    if (_persistence == null) {
1161                            _persistence = (BlogsStatsUserPersistence)PortalBeanLocatorUtil.locate(BlogsStatsUserPersistence.class.getName());
1162    
1163                            ReferenceRegistry.registerReference(BlogsStatsUserUtil.class,
1164                                    "_persistence");
1165                    }
1166    
1167                    return _persistence;
1168            }
1169    
1170            private static BlogsStatsUserPersistence _persistence;
1171    }