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