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