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