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