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