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