001    /**
002     * Copyright (c) 2000-present 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 aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.service.persistence.BasePersistence;
020    
021    import com.liferay.portlet.blogs.model.BlogsStatsUser;
022    
023    /**
024     * The persistence interface for the blogs stats user service.
025     *
026     * <p>
027     * Caching information and settings can be found in <code>portal.properties</code>
028     * </p>
029     *
030     * @author Brian Wing Shun Chan
031     * @see com.liferay.portlet.blogs.service.persistence.impl.BlogsStatsUserPersistenceImpl
032     * @see BlogsStatsUserUtil
033     * @generated
034     */
035    @ProviderType
036    public interface BlogsStatsUserPersistence extends BasePersistence<BlogsStatsUser> {
037            /*
038             * NOTE FOR DEVELOPERS:
039             *
040             * Never modify or reference this interface directly. Always use {@link BlogsStatsUserUtil} to access the blogs stats user persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface.
041             */
042    
043            /**
044            * Returns all the blogs stats users where groupId = &#63;.
045            *
046            * @param groupId the group ID
047            * @return the matching blogs stats users
048            */
049            public java.util.List<BlogsStatsUser> findByGroupId(long groupId);
050    
051            /**
052            * Returns a range of all the blogs stats users where groupId = &#63;.
053            *
054            * <p>
055            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
056            * </p>
057            *
058            * @param groupId the group ID
059            * @param start the lower bound of the range of blogs stats users
060            * @param end the upper bound of the range of blogs stats users (not inclusive)
061            * @return the range of matching blogs stats users
062            */
063            public java.util.List<BlogsStatsUser> findByGroupId(long groupId,
064                    int start, int end);
065    
066            /**
067            * Returns an ordered range of all the blogs stats users where groupId = &#63;.
068            *
069            * <p>
070            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
071            * </p>
072            *
073            * @param groupId the group ID
074            * @param start the lower bound of the range of blogs stats users
075            * @param end the upper bound of the range of blogs stats users (not inclusive)
076            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
077            * @return the ordered range of matching blogs stats users
078            */
079            public java.util.List<BlogsStatsUser> findByGroupId(long groupId,
080                    int start, int end,
081                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator);
082    
083            /**
084            * Returns the first blogs stats user in the ordered set where groupId = &#63;.
085            *
086            * @param groupId the group ID
087            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
088            * @return the first matching blogs stats user
089            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
090            */
091            public BlogsStatsUser findByGroupId_First(long groupId,
092                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator)
093                    throws com.liferay.portlet.blogs.NoSuchStatsUserException;
094    
095            /**
096            * Returns the first blogs stats user in the ordered set where groupId = &#63;.
097            *
098            * @param groupId the group ID
099            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
100            * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
101            */
102            public BlogsStatsUser fetchByGroupId_First(long groupId,
103                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator);
104    
105            /**
106            * Returns the last blogs stats user in the ordered set where groupId = &#63;.
107            *
108            * @param groupId the group ID
109            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
110            * @return the last matching blogs stats user
111            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
112            */
113            public BlogsStatsUser findByGroupId_Last(long groupId,
114                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator)
115                    throws com.liferay.portlet.blogs.NoSuchStatsUserException;
116    
117            /**
118            * Returns the last blogs stats user in the ordered set where groupId = &#63;.
119            *
120            * @param groupId the group ID
121            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
122            * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
123            */
124            public BlogsStatsUser fetchByGroupId_Last(long groupId,
125                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator);
126    
127            /**
128            * Returns the blogs stats users before and after the current blogs stats user in the ordered set where groupId = &#63;.
129            *
130            * @param statsUserId the primary key of the current blogs stats user
131            * @param groupId the group ID
132            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
133            * @return the previous, current, and next blogs stats user
134            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
135            */
136            public BlogsStatsUser[] findByGroupId_PrevAndNext(long statsUserId,
137                    long groupId,
138                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator)
139                    throws com.liferay.portlet.blogs.NoSuchStatsUserException;
140    
141            /**
142            * Removes all the blogs stats users where groupId = &#63; from the database.
143            *
144            * @param groupId the group ID
145            */
146            public void removeByGroupId(long groupId);
147    
148            /**
149            * Returns the number of blogs stats users where groupId = &#63;.
150            *
151            * @param groupId the group ID
152            * @return the number of matching blogs stats users
153            */
154            public int countByGroupId(long groupId);
155    
156            /**
157            * Returns all the blogs stats users where userId = &#63;.
158            *
159            * @param userId the user ID
160            * @return the matching blogs stats users
161            */
162            public java.util.List<BlogsStatsUser> findByUserId(long userId);
163    
164            /**
165            * Returns a range of all the blogs stats users where userId = &#63;.
166            *
167            * <p>
168            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
169            * </p>
170            *
171            * @param userId the user ID
172            * @param start the lower bound of the range of blogs stats users
173            * @param end the upper bound of the range of blogs stats users (not inclusive)
174            * @return the range of matching blogs stats users
175            */
176            public java.util.List<BlogsStatsUser> findByUserId(long userId, int start,
177                    int end);
178    
179            /**
180            * Returns an ordered range of all the blogs stats users where userId = &#63;.
181            *
182            * <p>
183            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
184            * </p>
185            *
186            * @param userId the user ID
187            * @param start the lower bound of the range of blogs stats users
188            * @param end the upper bound of the range of blogs stats users (not inclusive)
189            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
190            * @return the ordered range of matching blogs stats users
191            */
192            public java.util.List<BlogsStatsUser> findByUserId(long userId, int start,
193                    int end,
194                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator);
195    
196            /**
197            * Returns the first blogs stats user in the ordered set where userId = &#63;.
198            *
199            * @param userId the user ID
200            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
201            * @return the first matching blogs stats user
202            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
203            */
204            public BlogsStatsUser findByUserId_First(long userId,
205                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator)
206                    throws com.liferay.portlet.blogs.NoSuchStatsUserException;
207    
208            /**
209            * Returns the first blogs stats user in the ordered set where userId = &#63;.
210            *
211            * @param userId the user ID
212            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
213            * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
214            */
215            public BlogsStatsUser fetchByUserId_First(long userId,
216                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator);
217    
218            /**
219            * Returns the last blogs stats user in the ordered set where userId = &#63;.
220            *
221            * @param userId the user ID
222            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
223            * @return the last matching blogs stats user
224            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
225            */
226            public BlogsStatsUser findByUserId_Last(long userId,
227                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator)
228                    throws com.liferay.portlet.blogs.NoSuchStatsUserException;
229    
230            /**
231            * Returns the last blogs stats user in the ordered set where userId = &#63;.
232            *
233            * @param userId the user ID
234            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
235            * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
236            */
237            public BlogsStatsUser fetchByUserId_Last(long userId,
238                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator);
239    
240            /**
241            * Returns the blogs stats users before and after the current blogs stats user in the ordered set where userId = &#63;.
242            *
243            * @param statsUserId the primary key of the current blogs stats user
244            * @param userId the user ID
245            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
246            * @return the previous, current, and next blogs stats user
247            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
248            */
249            public BlogsStatsUser[] findByUserId_PrevAndNext(long statsUserId,
250                    long userId,
251                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator)
252                    throws com.liferay.portlet.blogs.NoSuchStatsUserException;
253    
254            /**
255            * Removes all the blogs stats users where userId = &#63; from the database.
256            *
257            * @param userId the user ID
258            */
259            public void removeByUserId(long userId);
260    
261            /**
262            * Returns the number of blogs stats users where userId = &#63;.
263            *
264            * @param userId the user ID
265            * @return the number of matching blogs stats users
266            */
267            public int countByUserId(long userId);
268    
269            /**
270            * Returns the blogs stats user where groupId = &#63; and userId = &#63; or throws a {@link NoSuchStatsUserException} if it could not be found.
271            *
272            * @param groupId the group ID
273            * @param userId the user ID
274            * @return the matching blogs stats user
275            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
276            */
277            public BlogsStatsUser findByG_U(long groupId, long userId)
278                    throws com.liferay.portlet.blogs.NoSuchStatsUserException;
279    
280            /**
281            * 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.
282            *
283            * @param groupId the group ID
284            * @param userId the user ID
285            * @return the matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
286            */
287            public BlogsStatsUser fetchByG_U(long groupId, long userId);
288    
289            /**
290            * 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.
291            *
292            * @param groupId the group ID
293            * @param userId the user ID
294            * @param retrieveFromCache whether to use the finder cache
295            * @return the matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
296            */
297            public BlogsStatsUser fetchByG_U(long groupId, long userId,
298                    boolean retrieveFromCache);
299    
300            /**
301            * Removes the blogs stats user where groupId = &#63; and userId = &#63; from the database.
302            *
303            * @param groupId the group ID
304            * @param userId the user ID
305            * @return the blogs stats user that was removed
306            */
307            public BlogsStatsUser removeByG_U(long groupId, long userId)
308                    throws com.liferay.portlet.blogs.NoSuchStatsUserException;
309    
310            /**
311            * Returns the number of blogs stats users where groupId = &#63; and userId = &#63;.
312            *
313            * @param groupId the group ID
314            * @param userId the user ID
315            * @return the number of matching blogs stats users
316            */
317            public int countByG_U(long groupId, long userId);
318    
319            /**
320            * Returns all the blogs stats users where groupId = &#63; and entryCount &ne; &#63;.
321            *
322            * @param groupId the group ID
323            * @param entryCount the entry count
324            * @return the matching blogs stats users
325            */
326            public java.util.List<BlogsStatsUser> findByG_NotE(long groupId,
327                    int entryCount);
328    
329            /**
330            * Returns a range of all the blogs stats users where groupId = &#63; and entryCount &ne; &#63;.
331            *
332            * <p>
333            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
334            * </p>
335            *
336            * @param groupId the group ID
337            * @param entryCount the entry count
338            * @param start the lower bound of the range of blogs stats users
339            * @param end the upper bound of the range of blogs stats users (not inclusive)
340            * @return the range of matching blogs stats users
341            */
342            public java.util.List<BlogsStatsUser> findByG_NotE(long groupId,
343                    int entryCount, int start, int end);
344    
345            /**
346            * Returns an ordered range of all the blogs stats users where groupId = &#63; and entryCount &ne; &#63;.
347            *
348            * <p>
349            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
350            * </p>
351            *
352            * @param groupId the group ID
353            * @param entryCount the entry count
354            * @param start the lower bound of the range of blogs stats users
355            * @param end the upper bound of the range of blogs stats users (not inclusive)
356            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
357            * @return the ordered range of matching blogs stats users
358            */
359            public java.util.List<BlogsStatsUser> findByG_NotE(long groupId,
360                    int entryCount, int start, int end,
361                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator);
362    
363            /**
364            * Returns the first blogs stats user in the ordered set where groupId = &#63; and entryCount &ne; &#63;.
365            *
366            * @param groupId the group ID
367            * @param entryCount the entry count
368            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
369            * @return the first matching blogs stats user
370            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
371            */
372            public BlogsStatsUser findByG_NotE_First(long groupId, int entryCount,
373                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator)
374                    throws com.liferay.portlet.blogs.NoSuchStatsUserException;
375    
376            /**
377            * Returns the first blogs stats user in the ordered set where groupId = &#63; and entryCount &ne; &#63;.
378            *
379            * @param groupId the group ID
380            * @param entryCount the entry count
381            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
382            * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
383            */
384            public BlogsStatsUser fetchByG_NotE_First(long groupId, int entryCount,
385                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator);
386    
387            /**
388            * Returns the last blogs stats user in the ordered set where groupId = &#63; and entryCount &ne; &#63;.
389            *
390            * @param groupId the group ID
391            * @param entryCount the entry count
392            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
393            * @return the last matching blogs stats user
394            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
395            */
396            public BlogsStatsUser findByG_NotE_Last(long groupId, int entryCount,
397                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator)
398                    throws com.liferay.portlet.blogs.NoSuchStatsUserException;
399    
400            /**
401            * Returns the last blogs stats user in the ordered set where groupId = &#63; and entryCount &ne; &#63;.
402            *
403            * @param groupId the group ID
404            * @param entryCount the entry count
405            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
406            * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
407            */
408            public BlogsStatsUser fetchByG_NotE_Last(long groupId, int entryCount,
409                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator);
410    
411            /**
412            * Returns the blogs stats users before and after the current blogs stats user in the ordered set where groupId = &#63; and entryCount &ne; &#63;.
413            *
414            * @param statsUserId the primary key of the current blogs stats user
415            * @param groupId the group ID
416            * @param entryCount the entry count
417            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
418            * @return the previous, current, and next blogs stats user
419            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
420            */
421            public BlogsStatsUser[] findByG_NotE_PrevAndNext(long statsUserId,
422                    long groupId, int entryCount,
423                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator)
424                    throws com.liferay.portlet.blogs.NoSuchStatsUserException;
425    
426            /**
427            * Removes all the blogs stats users where groupId = &#63; and entryCount &ne; &#63; from the database.
428            *
429            * @param groupId the group ID
430            * @param entryCount the entry count
431            */
432            public void removeByG_NotE(long groupId, int entryCount);
433    
434            /**
435            * Returns the number of blogs stats users where groupId = &#63; and entryCount &ne; &#63;.
436            *
437            * @param groupId the group ID
438            * @param entryCount the entry count
439            * @return the number of matching blogs stats users
440            */
441            public int countByG_NotE(long groupId, int entryCount);
442    
443            /**
444            * Returns all the blogs stats users where companyId = &#63; and entryCount &ne; &#63;.
445            *
446            * @param companyId the company ID
447            * @param entryCount the entry count
448            * @return the matching blogs stats users
449            */
450            public java.util.List<BlogsStatsUser> findByC_NotE(long companyId,
451                    int entryCount);
452    
453            /**
454            * Returns a range of all the blogs stats users where companyId = &#63; and entryCount &ne; &#63;.
455            *
456            * <p>
457            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
458            * </p>
459            *
460            * @param companyId the company ID
461            * @param entryCount the entry count
462            * @param start the lower bound of the range of blogs stats users
463            * @param end the upper bound of the range of blogs stats users (not inclusive)
464            * @return the range of matching blogs stats users
465            */
466            public java.util.List<BlogsStatsUser> findByC_NotE(long companyId,
467                    int entryCount, int start, int end);
468    
469            /**
470            * Returns an ordered range of all the blogs stats users where companyId = &#63; and entryCount &ne; &#63;.
471            *
472            * <p>
473            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
474            * </p>
475            *
476            * @param companyId the company ID
477            * @param entryCount the entry count
478            * @param start the lower bound of the range of blogs stats users
479            * @param end the upper bound of the range of blogs stats users (not inclusive)
480            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
481            * @return the ordered range of matching blogs stats users
482            */
483            public java.util.List<BlogsStatsUser> findByC_NotE(long companyId,
484                    int entryCount, int start, int end,
485                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator);
486    
487            /**
488            * Returns the first blogs stats user in the ordered set where companyId = &#63; and entryCount &ne; &#63;.
489            *
490            * @param companyId the company ID
491            * @param entryCount the entry count
492            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
493            * @return the first matching blogs stats user
494            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
495            */
496            public BlogsStatsUser findByC_NotE_First(long companyId, int entryCount,
497                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator)
498                    throws com.liferay.portlet.blogs.NoSuchStatsUserException;
499    
500            /**
501            * Returns the first blogs stats user in the ordered set where companyId = &#63; and entryCount &ne; &#63;.
502            *
503            * @param companyId the company ID
504            * @param entryCount the entry count
505            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
506            * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
507            */
508            public BlogsStatsUser fetchByC_NotE_First(long companyId, int entryCount,
509                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator);
510    
511            /**
512            * Returns the last blogs stats user in the ordered set where companyId = &#63; and entryCount &ne; &#63;.
513            *
514            * @param companyId the company ID
515            * @param entryCount the entry count
516            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
517            * @return the last matching blogs stats user
518            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
519            */
520            public BlogsStatsUser findByC_NotE_Last(long companyId, int entryCount,
521                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator)
522                    throws com.liferay.portlet.blogs.NoSuchStatsUserException;
523    
524            /**
525            * Returns the last blogs stats user in the ordered set where companyId = &#63; and entryCount &ne; &#63;.
526            *
527            * @param companyId the company ID
528            * @param entryCount the entry count
529            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
530            * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
531            */
532            public BlogsStatsUser fetchByC_NotE_Last(long companyId, int entryCount,
533                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator);
534    
535            /**
536            * Returns the blogs stats users before and after the current blogs stats user in the ordered set where companyId = &#63; and entryCount &ne; &#63;.
537            *
538            * @param statsUserId the primary key of the current blogs stats user
539            * @param companyId the company ID
540            * @param entryCount the entry count
541            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
542            * @return the previous, current, and next blogs stats user
543            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
544            */
545            public BlogsStatsUser[] findByC_NotE_PrevAndNext(long statsUserId,
546                    long companyId, int entryCount,
547                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator)
548                    throws com.liferay.portlet.blogs.NoSuchStatsUserException;
549    
550            /**
551            * Removes all the blogs stats users where companyId = &#63; and entryCount &ne; &#63; from the database.
552            *
553            * @param companyId the company ID
554            * @param entryCount the entry count
555            */
556            public void removeByC_NotE(long companyId, int entryCount);
557    
558            /**
559            * Returns the number of blogs stats users where companyId = &#63; and entryCount &ne; &#63;.
560            *
561            * @param companyId the company ID
562            * @param entryCount the entry count
563            * @return the number of matching blogs stats users
564            */
565            public int countByC_NotE(long companyId, int entryCount);
566    
567            /**
568            * Returns all the blogs stats users where userId = &#63; and lastPostDate = &#63;.
569            *
570            * @param userId the user ID
571            * @param lastPostDate the last post date
572            * @return the matching blogs stats users
573            */
574            public java.util.List<BlogsStatsUser> findByU_L(long userId,
575                    java.util.Date lastPostDate);
576    
577            /**
578            * Returns a range of all the blogs stats users where userId = &#63; and lastPostDate = &#63;.
579            *
580            * <p>
581            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
582            * </p>
583            *
584            * @param userId the user ID
585            * @param lastPostDate the last post date
586            * @param start the lower bound of the range of blogs stats users
587            * @param end the upper bound of the range of blogs stats users (not inclusive)
588            * @return the range of matching blogs stats users
589            */
590            public java.util.List<BlogsStatsUser> findByU_L(long userId,
591                    java.util.Date lastPostDate, int start, int end);
592    
593            /**
594            * Returns an ordered range of all the blogs stats users where userId = &#63; and lastPostDate = &#63;.
595            *
596            * <p>
597            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
598            * </p>
599            *
600            * @param userId the user ID
601            * @param lastPostDate the last post date
602            * @param start the lower bound of the range of blogs stats users
603            * @param end the upper bound of the range of blogs stats users (not inclusive)
604            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
605            * @return the ordered range of matching blogs stats users
606            */
607            public java.util.List<BlogsStatsUser> findByU_L(long userId,
608                    java.util.Date lastPostDate, int start, int end,
609                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator);
610    
611            /**
612            * Returns the first blogs stats user in the ordered set where userId = &#63; and lastPostDate = &#63;.
613            *
614            * @param userId the user ID
615            * @param lastPostDate the last post date
616            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
617            * @return the first matching blogs stats user
618            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
619            */
620            public BlogsStatsUser findByU_L_First(long userId,
621                    java.util.Date lastPostDate,
622                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator)
623                    throws com.liferay.portlet.blogs.NoSuchStatsUserException;
624    
625            /**
626            * Returns the first blogs stats user in the ordered set where userId = &#63; and lastPostDate = &#63;.
627            *
628            * @param userId the user ID
629            * @param lastPostDate the last post date
630            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
631            * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
632            */
633            public BlogsStatsUser fetchByU_L_First(long userId,
634                    java.util.Date lastPostDate,
635                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator);
636    
637            /**
638            * Returns the last blogs stats user in the ordered set where userId = &#63; and lastPostDate = &#63;.
639            *
640            * @param userId the user ID
641            * @param lastPostDate the last post date
642            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
643            * @return the last matching blogs stats user
644            * @throws NoSuchStatsUserException if a matching blogs stats user could not be found
645            */
646            public BlogsStatsUser findByU_L_Last(long userId,
647                    java.util.Date lastPostDate,
648                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator)
649                    throws com.liferay.portlet.blogs.NoSuchStatsUserException;
650    
651            /**
652            * Returns the last blogs stats user in the ordered set where userId = &#63; and lastPostDate = &#63;.
653            *
654            * @param userId the user ID
655            * @param lastPostDate the last post date
656            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
657            * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found
658            */
659            public BlogsStatsUser fetchByU_L_Last(long userId,
660                    java.util.Date lastPostDate,
661                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator);
662    
663            /**
664            * Returns the blogs stats users before and after the current blogs stats user in the ordered set where userId = &#63; and lastPostDate = &#63;.
665            *
666            * @param statsUserId the primary key of the current blogs stats user
667            * @param userId the user ID
668            * @param lastPostDate the last post date
669            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
670            * @return the previous, current, and next blogs stats user
671            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
672            */
673            public BlogsStatsUser[] findByU_L_PrevAndNext(long statsUserId,
674                    long userId, java.util.Date lastPostDate,
675                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator)
676                    throws com.liferay.portlet.blogs.NoSuchStatsUserException;
677    
678            /**
679            * Removes all the blogs stats users where userId = &#63; and lastPostDate = &#63; from the database.
680            *
681            * @param userId the user ID
682            * @param lastPostDate the last post date
683            */
684            public void removeByU_L(long userId, java.util.Date lastPostDate);
685    
686            /**
687            * Returns the number of blogs stats users where userId = &#63; and lastPostDate = &#63;.
688            *
689            * @param userId the user ID
690            * @param lastPostDate the last post date
691            * @return the number of matching blogs stats users
692            */
693            public int countByU_L(long userId, java.util.Date lastPostDate);
694    
695            /**
696            * Caches the blogs stats user in the entity cache if it is enabled.
697            *
698            * @param blogsStatsUser the blogs stats user
699            */
700            public void cacheResult(BlogsStatsUser blogsStatsUser);
701    
702            /**
703            * Caches the blogs stats users in the entity cache if it is enabled.
704            *
705            * @param blogsStatsUsers the blogs stats users
706            */
707            public void cacheResult(java.util.List<BlogsStatsUser> blogsStatsUsers);
708    
709            /**
710            * Creates a new blogs stats user with the primary key. Does not add the blogs stats user to the database.
711            *
712            * @param statsUserId the primary key for the new blogs stats user
713            * @return the new blogs stats user
714            */
715            public BlogsStatsUser create(long statsUserId);
716    
717            /**
718            * Removes the blogs stats user with the primary key from the database. Also notifies the appropriate model listeners.
719            *
720            * @param statsUserId the primary key of the blogs stats user
721            * @return the blogs stats user that was removed
722            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
723            */
724            public BlogsStatsUser remove(long statsUserId)
725                    throws com.liferay.portlet.blogs.NoSuchStatsUserException;
726    
727            public BlogsStatsUser updateImpl(BlogsStatsUser blogsStatsUser);
728    
729            /**
730            * Returns the blogs stats user with the primary key or throws a {@link NoSuchStatsUserException} if it could not be found.
731            *
732            * @param statsUserId the primary key of the blogs stats user
733            * @return the blogs stats user
734            * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found
735            */
736            public BlogsStatsUser findByPrimaryKey(long statsUserId)
737                    throws com.liferay.portlet.blogs.NoSuchStatsUserException;
738    
739            /**
740            * Returns the blogs stats user with the primary key or returns <code>null</code> if it could not be found.
741            *
742            * @param statsUserId the primary key of the blogs stats user
743            * @return the blogs stats user, or <code>null</code> if a blogs stats user with the primary key could not be found
744            */
745            public BlogsStatsUser fetchByPrimaryKey(long statsUserId);
746    
747            @Override
748            public java.util.Map<java.io.Serializable, BlogsStatsUser> fetchByPrimaryKeys(
749                    java.util.Set<java.io.Serializable> primaryKeys);
750    
751            /**
752            * Returns all the blogs stats users.
753            *
754            * @return the blogs stats users
755            */
756            public java.util.List<BlogsStatsUser> findAll();
757    
758            /**
759            * Returns a range of all the blogs stats users.
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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
763            * </p>
764            *
765            * @param start the lower bound of the range of blogs stats users
766            * @param end the upper bound of the range of blogs stats users (not inclusive)
767            * @return the range of blogs stats users
768            */
769            public java.util.List<BlogsStatsUser> findAll(int start, int end);
770    
771            /**
772            * Returns an ordered range of all the blogs stats users.
773            *
774            * <p>
775            * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
776            * </p>
777            *
778            * @param start the lower bound of the range of blogs stats users
779            * @param end the upper bound of the range of blogs stats users (not inclusive)
780            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
781            * @return the ordered range of blogs stats users
782            */
783            public java.util.List<BlogsStatsUser> findAll(int start, int end,
784                    com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator);
785    
786            /**
787            * Removes all the blogs stats users from the database.
788            */
789            public void removeAll();
790    
791            /**
792            * Returns the number of blogs stats users.
793            *
794            * @return the number of blogs stats users
795            */
796            public int countAll();
797    }