001    /**
002     * Copyright (c) 2000-2011 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.blogs.service.persistence;
016    
017    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
018    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
019    import com.liferay.portal.kernel.exception.SystemException;
020    import com.liferay.portal.kernel.util.OrderByComparator;
021    import com.liferay.portal.kernel.util.ReferenceRegistry;
022    import com.liferay.portal.service.ServiceContext;
023    
024    import com.liferay.portlet.blogs.model.BlogsStatsUser;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the blogs stats user service. This utility wraps {@link BlogsStatsUserPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
030     *
031     * <p>
032     * Caching information and settings can be found in <code>portal.properties</code>
033     * </p>
034     *
035     * @author Brian Wing Shun Chan
036     * @see BlogsStatsUserPersistence
037     * @see BlogsStatsUserPersistenceImpl
038     * @generated
039     */
040    public class BlogsStatsUserUtil {
041            /*
042             * NOTE FOR DEVELOPERS:
043             *
044             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
045             */
046    
047            /**
048             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
049             */
050            public static void clearCache() {
051                    getPersistence().clearCache();
052            }
053    
054            /**
055             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
056             */
057            public static void clearCache(BlogsStatsUser blogsStatsUser) {
058                    getPersistence().clearCache(blogsStatsUser);
059            }
060    
061            /**
062             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
063             */
064            public long countWithDynamicQuery(DynamicQuery dynamicQuery)
065                    throws SystemException {
066                    return getPersistence().countWithDynamicQuery(dynamicQuery);
067            }
068    
069            /**
070             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
071             */
072            public static List<BlogsStatsUser> findWithDynamicQuery(
073                    DynamicQuery dynamicQuery) throws SystemException {
074                    return getPersistence().findWithDynamicQuery(dynamicQuery);
075            }
076    
077            /**
078             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
079             */
080            public static List<BlogsStatsUser> findWithDynamicQuery(
081                    DynamicQuery dynamicQuery, int start, int end)
082                    throws SystemException {
083                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
084            }
085    
086            /**
087             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
088             */
089            public static List<BlogsStatsUser> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator orderByComparator) throws SystemException {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#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
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
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
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            * Returns 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
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            * Returns 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
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            * Returns all the blogs stats users where groupId = &#63;.
204            *
205            * @param groupId the group ID
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            * Returns 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
223            * @param start the lower bound of the range of blogs stats users
224            * @param end the upper bound of the range of blogs stats users (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            * Returns 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
242            * @param start the lower bound of the range of blogs stats users
243            * @param end the upper bound of the range of blogs stats users (not inclusive)
244            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
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            * Returns 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
264            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
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            * Returns 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
285            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
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            * Returns 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
307            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
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            * Returns all the blogs stats users where userId = &#63;.
324            *
325            * @param userId the user ID
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            * Returns 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
342            * @param start the lower bound of the range of blogs stats users
343            * @param end the upper bound of the range of blogs stats users (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            * Returns 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
361            * @param start the lower bound of the range of blogs stats users
362            * @param end the upper bound of the range of blogs stats users (not inclusive)
363            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
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            * Returns 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
383            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
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            * Returns 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
404            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
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            * Returns 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
426            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
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            * Returns the blogs stats user where groupId = &#63; and userId = &#63; or throws a {@link com.liferay.portlet.blogs.NoSuchStatsUserException} if it could not be found.
443            *
444            * @param groupId the group ID
445            * @param userId the user ID
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            * Returns the blogs stats user where groupId = &#63; and userId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
459            *
460            * @param groupId the group ID
461            * @param userId the user ID
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            * Returns the blogs stats user where groupId = &#63; and userId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
473            *
474            * @param groupId the group ID
475            * @param userId the user ID
476            * @param retrieveFromCache whether to use the finder cache
477            * @return the matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
478            * @throws SystemException if a system exception occurred
479            */
480            public static com.liferay.portlet.blogs.model.BlogsStatsUser fetchByG_U(
481                    long groupId, long userId, boolean retrieveFromCache)
482                    throws com.liferay.portal.kernel.exception.SystemException {
483                    return getPersistence().fetchByG_U(groupId, userId, retrieveFromCache);
484            }
485    
486            /**
487            * Returns all the blogs stats users where groupId = &#63; and entryCount &ne; &#63;.
488            *
489            * @param groupId the group ID
490            * @param entryCount the entry count
491            * @return the matching blogs stats users
492            * @throws SystemException if a system exception occurred
493            */
494            public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByG_NotE(
495                    long groupId, int entryCount)
496                    throws com.liferay.portal.kernel.exception.SystemException {
497                    return getPersistence().findByG_NotE(groupId, entryCount);
498            }
499    
500            /**
501            * Returns a range of all the blogs stats users where groupId = &#63; and entryCount &ne; &#63;.
502            *
503            * <p>
504            * 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.
505            * </p>
506            *
507            * @param groupId the group ID
508            * @param entryCount the entry count
509            * @param start the lower bound of the range of blogs stats users
510            * @param end the upper bound of the range of blogs stats users (not inclusive)
511            * @return the range of matching blogs stats users
512            * @throws SystemException if a system exception occurred
513            */
514            public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByG_NotE(
515                    long groupId, int entryCount, int start, int end)
516                    throws com.liferay.portal.kernel.exception.SystemException {
517                    return getPersistence().findByG_NotE(groupId, entryCount, start, end);
518            }
519    
520            /**
521            * Returns an ordered range of all the blogs stats users where groupId = &#63; and entryCount &ne; &#63;.
522            *
523            * <p>
524            * 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.
525            * </p>
526            *
527            * @param groupId the group ID
528            * @param entryCount the entry count
529            * @param start the lower bound of the range of blogs stats users
530            * @param end the upper bound of the range of blogs stats users (not inclusive)
531            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
532            * @return the ordered range of matching blogs stats users
533            * @throws SystemException if a system exception occurred
534            */
535            public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByG_NotE(
536                    long groupId, int entryCount, int start, int end,
537                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
538                    throws com.liferay.portal.kernel.exception.SystemException {
539                    return getPersistence()
540                                       .findByG_NotE(groupId, entryCount, start, end,
541                            orderByComparator);
542            }
543    
544            /**
545            * Returns the first blogs stats user in the ordered set where groupId = &#63; and entryCount &ne; &#63;.
546            *
547            * <p>
548            * 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.
549            * </p>
550            *
551            * @param groupId the group ID
552            * @param entryCount the entry count
553            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
554            * @return the first matching blogs stats user
555            * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a matching blogs stats user could not be found
556            * @throws SystemException if a system exception occurred
557            */
558            public static com.liferay.portlet.blogs.model.BlogsStatsUser findByG_NotE_First(
559                    long groupId, int entryCount,
560                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
561                    throws com.liferay.portal.kernel.exception.SystemException,
562                            com.liferay.portlet.blogs.NoSuchStatsUserException {
563                    return getPersistence()
564                                       .findByG_NotE_First(groupId, entryCount, orderByComparator);
565            }
566    
567            /**
568            * Returns the last blogs stats user in the ordered set where groupId = &#63; and entryCount &ne; &#63;.
569            *
570            * <p>
571            * 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.
572            * </p>
573            *
574            * @param groupId the group ID
575            * @param entryCount the entry count
576            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
577            * @return the last matching blogs stats user
578            * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a matching blogs stats user could not be found
579            * @throws SystemException if a system exception occurred
580            */
581            public static com.liferay.portlet.blogs.model.BlogsStatsUser findByG_NotE_Last(
582                    long groupId, int entryCount,
583                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
584                    throws com.liferay.portal.kernel.exception.SystemException,
585                            com.liferay.portlet.blogs.NoSuchStatsUserException {
586                    return getPersistence()
587                                       .findByG_NotE_Last(groupId, entryCount, orderByComparator);
588            }
589    
590            /**
591            * Returns the blogs stats users before and after the current blogs stats user in the ordered set where groupId = &#63; and entryCount &ne; &#63;.
592            *
593            * <p>
594            * 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.
595            * </p>
596            *
597            * @param statsUserId the primary key of the current blogs stats user
598            * @param groupId the group ID
599            * @param entryCount the entry count
600            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
601            * @return the previous, current, and next blogs stats user
602            * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a blogs stats user with the primary key could not be found
603            * @throws SystemException if a system exception occurred
604            */
605            public static com.liferay.portlet.blogs.model.BlogsStatsUser[] findByG_NotE_PrevAndNext(
606                    long statsUserId, long groupId, int entryCount,
607                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
608                    throws com.liferay.portal.kernel.exception.SystemException,
609                            com.liferay.portlet.blogs.NoSuchStatsUserException {
610                    return getPersistence()
611                                       .findByG_NotE_PrevAndNext(statsUserId, groupId, entryCount,
612                            orderByComparator);
613            }
614    
615            /**
616            * Returns all the blogs stats users where companyId = &#63; and entryCount &ne; &#63;.
617            *
618            * @param companyId the company ID
619            * @param entryCount the entry count
620            * @return the matching blogs stats users
621            * @throws SystemException if a system exception occurred
622            */
623            public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByC_NotE(
624                    long companyId, int entryCount)
625                    throws com.liferay.portal.kernel.exception.SystemException {
626                    return getPersistence().findByC_NotE(companyId, entryCount);
627            }
628    
629            /**
630            * Returns a range of all the blogs stats users where companyId = &#63; and entryCount &ne; &#63;.
631            *
632            * <p>
633            * 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.
634            * </p>
635            *
636            * @param companyId the company ID
637            * @param entryCount the entry count
638            * @param start the lower bound of the range of blogs stats users
639            * @param end the upper bound of the range of blogs stats users (not inclusive)
640            * @return the range of matching blogs stats users
641            * @throws SystemException if a system exception occurred
642            */
643            public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByC_NotE(
644                    long companyId, int entryCount, int start, int end)
645                    throws com.liferay.portal.kernel.exception.SystemException {
646                    return getPersistence().findByC_NotE(companyId, entryCount, start, end);
647            }
648    
649            /**
650            * Returns an ordered range of all the blogs stats users where companyId = &#63; and entryCount &ne; &#63;.
651            *
652            * <p>
653            * 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.
654            * </p>
655            *
656            * @param companyId the company ID
657            * @param entryCount the entry count
658            * @param start the lower bound of the range of blogs stats users
659            * @param end the upper bound of the range of blogs stats users (not inclusive)
660            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
661            * @return the ordered range of matching blogs stats users
662            * @throws SystemException if a system exception occurred
663            */
664            public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByC_NotE(
665                    long companyId, int entryCount, int start, int end,
666                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
667                    throws com.liferay.portal.kernel.exception.SystemException {
668                    return getPersistence()
669                                       .findByC_NotE(companyId, entryCount, start, end,
670                            orderByComparator);
671            }
672    
673            /**
674            * Returns the first blogs stats user in the ordered set where companyId = &#63; and entryCount &ne; &#63;.
675            *
676            * <p>
677            * 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.
678            * </p>
679            *
680            * @param companyId the company ID
681            * @param entryCount the entry count
682            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
683            * @return the first matching blogs stats user
684            * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a matching blogs stats user could not be found
685            * @throws SystemException if a system exception occurred
686            */
687            public static com.liferay.portlet.blogs.model.BlogsStatsUser findByC_NotE_First(
688                    long companyId, int entryCount,
689                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
690                    throws com.liferay.portal.kernel.exception.SystemException,
691                            com.liferay.portlet.blogs.NoSuchStatsUserException {
692                    return getPersistence()
693                                       .findByC_NotE_First(companyId, entryCount, orderByComparator);
694            }
695    
696            /**
697            * Returns the last blogs stats user in the ordered set where companyId = &#63; and entryCount &ne; &#63;.
698            *
699            * <p>
700            * 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.
701            * </p>
702            *
703            * @param companyId the company ID
704            * @param entryCount the entry count
705            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
706            * @return the last matching blogs stats user
707            * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a matching blogs stats user could not be found
708            * @throws SystemException if a system exception occurred
709            */
710            public static com.liferay.portlet.blogs.model.BlogsStatsUser findByC_NotE_Last(
711                    long companyId, int entryCount,
712                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
713                    throws com.liferay.portal.kernel.exception.SystemException,
714                            com.liferay.portlet.blogs.NoSuchStatsUserException {
715                    return getPersistence()
716                                       .findByC_NotE_Last(companyId, entryCount, orderByComparator);
717            }
718    
719            /**
720            * Returns the blogs stats users before and after the current blogs stats user in the ordered set where companyId = &#63; and entryCount &ne; &#63;.
721            *
722            * <p>
723            * 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.
724            * </p>
725            *
726            * @param statsUserId the primary key of the current blogs stats user
727            * @param companyId the company ID
728            * @param entryCount the entry count
729            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
730            * @return the previous, current, and next blogs stats user
731            * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a blogs stats user with the primary key could not be found
732            * @throws SystemException if a system exception occurred
733            */
734            public static com.liferay.portlet.blogs.model.BlogsStatsUser[] findByC_NotE_PrevAndNext(
735                    long statsUserId, long companyId, int entryCount,
736                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
737                    throws com.liferay.portal.kernel.exception.SystemException,
738                            com.liferay.portlet.blogs.NoSuchStatsUserException {
739                    return getPersistence()
740                                       .findByC_NotE_PrevAndNext(statsUserId, companyId,
741                            entryCount, orderByComparator);
742            }
743    
744            /**
745            * Returns all the blogs stats users where userId = &#63; and lastPostDate = &#63;.
746            *
747            * @param userId the user ID
748            * @param lastPostDate the last post date
749            * @return the matching blogs stats users
750            * @throws SystemException if a system exception occurred
751            */
752            public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByU_L(
753                    long userId, java.util.Date lastPostDate)
754                    throws com.liferay.portal.kernel.exception.SystemException {
755                    return getPersistence().findByU_L(userId, lastPostDate);
756            }
757    
758            /**
759            * Returns a range of all the blogs stats users where userId = &#63; and lastPostDate = &#63;.
760            *
761            * <p>
762            * 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.
763            * </p>
764            *
765            * @param userId the user ID
766            * @param lastPostDate the last post date
767            * @param start the lower bound of the range of blogs stats users
768            * @param end the upper bound of the range of blogs stats users (not inclusive)
769            * @return the range of matching blogs stats users
770            * @throws SystemException if a system exception occurred
771            */
772            public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByU_L(
773                    long userId, java.util.Date lastPostDate, int start, int end)
774                    throws com.liferay.portal.kernel.exception.SystemException {
775                    return getPersistence().findByU_L(userId, lastPostDate, start, end);
776            }
777    
778            /**
779            * Returns an ordered range of all the blogs stats users where userId = &#63; and lastPostDate = &#63;.
780            *
781            * <p>
782            * 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.
783            * </p>
784            *
785            * @param userId the user ID
786            * @param lastPostDate the last post date
787            * @param start the lower bound of the range of blogs stats users
788            * @param end the upper bound of the range of blogs stats users (not inclusive)
789            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
790            * @return the ordered range of matching blogs stats users
791            * @throws SystemException if a system exception occurred
792            */
793            public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByU_L(
794                    long userId, java.util.Date lastPostDate, int start, int end,
795                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
796                    throws com.liferay.portal.kernel.exception.SystemException {
797                    return getPersistence()
798                                       .findByU_L(userId, lastPostDate, start, end,
799                            orderByComparator);
800            }
801    
802            /**
803            * Returns the first blogs stats user in the ordered set where userId = &#63; and lastPostDate = &#63;.
804            *
805            * <p>
806            * 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.
807            * </p>
808            *
809            * @param userId the user ID
810            * @param lastPostDate the last post date
811            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
812            * @return the first matching blogs stats user
813            * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a matching blogs stats user could not be found
814            * @throws SystemException if a system exception occurred
815            */
816            public static com.liferay.portlet.blogs.model.BlogsStatsUser findByU_L_First(
817                    long userId, java.util.Date lastPostDate,
818                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
819                    throws com.liferay.portal.kernel.exception.SystemException,
820                            com.liferay.portlet.blogs.NoSuchStatsUserException {
821                    return getPersistence()
822                                       .findByU_L_First(userId, lastPostDate, orderByComparator);
823            }
824    
825            /**
826            * Returns the last blogs stats user in the ordered set where userId = &#63; and lastPostDate = &#63;.
827            *
828            * <p>
829            * 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.
830            * </p>
831            *
832            * @param userId the user ID
833            * @param lastPostDate the last post date
834            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
835            * @return the last matching blogs stats user
836            * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a matching blogs stats user could not be found
837            * @throws SystemException if a system exception occurred
838            */
839            public static com.liferay.portlet.blogs.model.BlogsStatsUser findByU_L_Last(
840                    long userId, java.util.Date lastPostDate,
841                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
842                    throws com.liferay.portal.kernel.exception.SystemException,
843                            com.liferay.portlet.blogs.NoSuchStatsUserException {
844                    return getPersistence()
845                                       .findByU_L_Last(userId, lastPostDate, orderByComparator);
846            }
847    
848            /**
849            * Returns the blogs stats users before and after the current blogs stats user in the ordered set where userId = &#63; and lastPostDate = &#63;.
850            *
851            * <p>
852            * 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.
853            * </p>
854            *
855            * @param statsUserId the primary key of the current blogs stats user
856            * @param userId the user ID
857            * @param lastPostDate the last post date
858            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
859            * @return the previous, current, and next blogs stats user
860            * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a blogs stats user with the primary key could not be found
861            * @throws SystemException if a system exception occurred
862            */
863            public static com.liferay.portlet.blogs.model.BlogsStatsUser[] findByU_L_PrevAndNext(
864                    long statsUserId, long userId, java.util.Date lastPostDate,
865                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
866                    throws com.liferay.portal.kernel.exception.SystemException,
867                            com.liferay.portlet.blogs.NoSuchStatsUserException {
868                    return getPersistence()
869                                       .findByU_L_PrevAndNext(statsUserId, userId, lastPostDate,
870                            orderByComparator);
871            }
872    
873            /**
874            * Returns all the blogs stats users.
875            *
876            * @return the blogs stats users
877            * @throws SystemException if a system exception occurred
878            */
879            public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findAll()
880                    throws com.liferay.portal.kernel.exception.SystemException {
881                    return getPersistence().findAll();
882            }
883    
884            /**
885            * Returns a range of all the blogs stats users.
886            *
887            * <p>
888            * 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.
889            * </p>
890            *
891            * @param start the lower bound of the range of blogs stats users
892            * @param end the upper bound of the range of blogs stats users (not inclusive)
893            * @return the range of blogs stats users
894            * @throws SystemException if a system exception occurred
895            */
896            public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findAll(
897                    int start, int end)
898                    throws com.liferay.portal.kernel.exception.SystemException {
899                    return getPersistence().findAll(start, end);
900            }
901    
902            /**
903            * Returns an ordered range of all the blogs stats users.
904            *
905            * <p>
906            * 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.
907            * </p>
908            *
909            * @param start the lower bound of the range of blogs stats users
910            * @param end the upper bound of the range of blogs stats users (not inclusive)
911            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
912            * @return the ordered range of blogs stats users
913            * @throws SystemException if a system exception occurred
914            */
915            public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findAll(
916                    int start, int end,
917                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
918                    throws com.liferay.portal.kernel.exception.SystemException {
919                    return getPersistence().findAll(start, end, orderByComparator);
920            }
921    
922            /**
923            * Removes all the blogs stats users where groupId = &#63; from the database.
924            *
925            * @param groupId the group ID
926            * @throws SystemException if a system exception occurred
927            */
928            public static void removeByGroupId(long groupId)
929                    throws com.liferay.portal.kernel.exception.SystemException {
930                    getPersistence().removeByGroupId(groupId);
931            }
932    
933            /**
934            * Removes all the blogs stats users where userId = &#63; from the database.
935            *
936            * @param userId the user ID
937            * @throws SystemException if a system exception occurred
938            */
939            public static void removeByUserId(long userId)
940                    throws com.liferay.portal.kernel.exception.SystemException {
941                    getPersistence().removeByUserId(userId);
942            }
943    
944            /**
945            * Removes the blogs stats user where groupId = &#63; and userId = &#63; from the database.
946            *
947            * @param groupId the group ID
948            * @param userId the user ID
949            * @throws SystemException if a system exception occurred
950            */
951            public static void removeByG_U(long groupId, long userId)
952                    throws com.liferay.portal.kernel.exception.SystemException,
953                            com.liferay.portlet.blogs.NoSuchStatsUserException {
954                    getPersistence().removeByG_U(groupId, userId);
955            }
956    
957            /**
958            * Removes all the blogs stats users where groupId = &#63; and entryCount &ne; &#63; from the database.
959            *
960            * @param groupId the group ID
961            * @param entryCount the entry count
962            * @throws SystemException if a system exception occurred
963            */
964            public static void removeByG_NotE(long groupId, int entryCount)
965                    throws com.liferay.portal.kernel.exception.SystemException {
966                    getPersistence().removeByG_NotE(groupId, entryCount);
967            }
968    
969            /**
970            * Removes all the blogs stats users where companyId = &#63; and entryCount &ne; &#63; from the database.
971            *
972            * @param companyId the company ID
973            * @param entryCount the entry count
974            * @throws SystemException if a system exception occurred
975            */
976            public static void removeByC_NotE(long companyId, int entryCount)
977                    throws com.liferay.portal.kernel.exception.SystemException {
978                    getPersistence().removeByC_NotE(companyId, entryCount);
979            }
980    
981            /**
982            * Removes all the blogs stats users where userId = &#63; and lastPostDate = &#63; from the database.
983            *
984            * @param userId the user ID
985            * @param lastPostDate the last post date
986            * @throws SystemException if a system exception occurred
987            */
988            public static void removeByU_L(long userId, java.util.Date lastPostDate)
989                    throws com.liferay.portal.kernel.exception.SystemException {
990                    getPersistence().removeByU_L(userId, lastPostDate);
991            }
992    
993            /**
994            * Removes all the blogs stats users from the database.
995            *
996            * @throws SystemException if a system exception occurred
997            */
998            public static void removeAll()
999                    throws com.liferay.portal.kernel.exception.SystemException {
1000                    getPersistence().removeAll();
1001            }
1002    
1003            /**
1004            * Returns the number of blogs stats users where groupId = &#63;.
1005            *
1006            * @param groupId the group ID
1007            * @return the number of matching blogs stats users
1008            * @throws SystemException if a system exception occurred
1009            */
1010            public static int countByGroupId(long groupId)
1011                    throws com.liferay.portal.kernel.exception.SystemException {
1012                    return getPersistence().countByGroupId(groupId);
1013            }
1014    
1015            /**
1016            * Returns the number of blogs stats users where userId = &#63;.
1017            *
1018            * @param userId the user ID
1019            * @return the number of matching blogs stats users
1020            * @throws SystemException if a system exception occurred
1021            */
1022            public static int countByUserId(long userId)
1023                    throws com.liferay.portal.kernel.exception.SystemException {
1024                    return getPersistence().countByUserId(userId);
1025            }
1026    
1027            /**
1028            * Returns the number of blogs stats users where groupId = &#63; and userId = &#63;.
1029            *
1030            * @param groupId the group ID
1031            * @param userId the user ID
1032            * @return the number of matching blogs stats users
1033            * @throws SystemException if a system exception occurred
1034            */
1035            public static int countByG_U(long groupId, long userId)
1036                    throws com.liferay.portal.kernel.exception.SystemException {
1037                    return getPersistence().countByG_U(groupId, userId);
1038            }
1039    
1040            /**
1041            * Returns the number of blogs stats users where groupId = &#63; and entryCount &ne; &#63;.
1042            *
1043            * @param groupId the group ID
1044            * @param entryCount the entry count
1045            * @return the number of matching blogs stats users
1046            * @throws SystemException if a system exception occurred
1047            */
1048            public static int countByG_NotE(long groupId, int entryCount)
1049                    throws com.liferay.portal.kernel.exception.SystemException {
1050                    return getPersistence().countByG_NotE(groupId, entryCount);
1051            }
1052    
1053            /**
1054            * Returns the number of blogs stats users where companyId = &#63; and entryCount &ne; &#63;.
1055            *
1056            * @param companyId the company ID
1057            * @param entryCount the entry count
1058            * @return the number of matching blogs stats users
1059            * @throws SystemException if a system exception occurred
1060            */
1061            public static int countByC_NotE(long companyId, int entryCount)
1062                    throws com.liferay.portal.kernel.exception.SystemException {
1063                    return getPersistence().countByC_NotE(companyId, entryCount);
1064            }
1065    
1066            /**
1067            * Returns the number of blogs stats users where userId = &#63; and lastPostDate = &#63;.
1068            *
1069            * @param userId the user ID
1070            * @param lastPostDate the last post date
1071            * @return the number of matching blogs stats users
1072            * @throws SystemException if a system exception occurred
1073            */
1074            public static int countByU_L(long userId, java.util.Date lastPostDate)
1075                    throws com.liferay.portal.kernel.exception.SystemException {
1076                    return getPersistence().countByU_L(userId, lastPostDate);
1077            }
1078    
1079            /**
1080            * Returns the number of blogs stats users.
1081            *
1082            * @return the number of blogs stats users
1083            * @throws SystemException if a system exception occurred
1084            */
1085            public static int countAll()
1086                    throws com.liferay.portal.kernel.exception.SystemException {
1087                    return getPersistence().countAll();
1088            }
1089    
1090            public static BlogsStatsUserPersistence getPersistence() {
1091                    if (_persistence == null) {
1092                            _persistence = (BlogsStatsUserPersistence)PortalBeanLocatorUtil.locate(BlogsStatsUserPersistence.class.getName());
1093    
1094                            ReferenceRegistry.registerReference(BlogsStatsUserUtil.class,
1095                                    "_persistence");
1096                    }
1097    
1098                    return _persistence;
1099            }
1100    
1101            public void setPersistence(BlogsStatsUserPersistence persistence) {
1102                    _persistence = persistence;
1103    
1104                    ReferenceRegistry.registerReference(BlogsStatsUserUtil.class,
1105                            "_persistence");
1106            }
1107    
1108            private static BlogsStatsUserPersistence _persistence;
1109    }