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 = ?. 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 = ?. 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 = ?. 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 an ordered range of all the blogs stats users where groupId = ?. 085 * 086 * <p> 087 * 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. 088 * </p> 089 * 090 * @param groupId the group ID 091 * @param start the lower bound of the range of blogs stats users 092 * @param end the upper bound of the range of blogs stats users (not inclusive) 093 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 094 * @param retrieveFromCache whether to retrieve from the finder cache 095 * @return the ordered range of matching blogs stats users 096 */ 097 public java.util.List<BlogsStatsUser> findByGroupId(long groupId, 098 int start, int end, 099 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator, 100 boolean retrieveFromCache); 101 102 /** 103 * Returns the first blogs stats user in the ordered set where groupId = ?. 104 * 105 * @param groupId the group ID 106 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 107 * @return the first matching blogs stats user 108 * @throws NoSuchStatsUserException if a matching blogs stats user could not be found 109 */ 110 public BlogsStatsUser findByGroupId_First(long groupId, 111 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator) 112 throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException; 113 114 /** 115 * Returns the first blogs stats user in the ordered set where groupId = ?. 116 * 117 * @param groupId the group ID 118 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 119 * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found 120 */ 121 public BlogsStatsUser fetchByGroupId_First(long groupId, 122 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator); 123 124 /** 125 * Returns the last blogs stats user in the ordered set where groupId = ?. 126 * 127 * @param groupId the group ID 128 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 129 * @return the last matching blogs stats user 130 * @throws NoSuchStatsUserException if a matching blogs stats user could not be found 131 */ 132 public BlogsStatsUser findByGroupId_Last(long groupId, 133 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator) 134 throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException; 135 136 /** 137 * Returns the last blogs stats user in the ordered set where groupId = ?. 138 * 139 * @param groupId the group ID 140 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 141 * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found 142 */ 143 public BlogsStatsUser fetchByGroupId_Last(long groupId, 144 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator); 145 146 /** 147 * Returns the blogs stats users before and after the current blogs stats user in the ordered set where groupId = ?. 148 * 149 * @param statsUserId the primary key of the current blogs stats user 150 * @param groupId the group ID 151 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 152 * @return the previous, current, and next blogs stats user 153 * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found 154 */ 155 public BlogsStatsUser[] findByGroupId_PrevAndNext(long statsUserId, 156 long groupId, 157 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator) 158 throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException; 159 160 /** 161 * Removes all the blogs stats users where groupId = ? from the database. 162 * 163 * @param groupId the group ID 164 */ 165 public void removeByGroupId(long groupId); 166 167 /** 168 * Returns the number of blogs stats users where groupId = ?. 169 * 170 * @param groupId the group ID 171 * @return the number of matching blogs stats users 172 */ 173 public int countByGroupId(long groupId); 174 175 /** 176 * Returns all the blogs stats users where userId = ?. 177 * 178 * @param userId the user ID 179 * @return the matching blogs stats users 180 */ 181 public java.util.List<BlogsStatsUser> findByUserId(long userId); 182 183 /** 184 * Returns a range of all the blogs stats users where userId = ?. 185 * 186 * <p> 187 * 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. 188 * </p> 189 * 190 * @param userId the user ID 191 * @param start the lower bound of the range of blogs stats users 192 * @param end the upper bound of the range of blogs stats users (not inclusive) 193 * @return the range of matching blogs stats users 194 */ 195 public java.util.List<BlogsStatsUser> findByUserId(long userId, int start, 196 int end); 197 198 /** 199 * Returns an ordered range of all the blogs stats users where userId = ?. 200 * 201 * <p> 202 * 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. 203 * </p> 204 * 205 * @param userId the user ID 206 * @param start the lower bound of the range of blogs stats users 207 * @param end the upper bound of the range of blogs stats users (not inclusive) 208 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 209 * @return the ordered range of matching blogs stats users 210 */ 211 public java.util.List<BlogsStatsUser> findByUserId(long userId, int start, 212 int end, 213 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator); 214 215 /** 216 * Returns an ordered range of all the blogs stats users where userId = ?. 217 * 218 * <p> 219 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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. 220 * </p> 221 * 222 * @param userId the user ID 223 * @param start the lower bound of the range of blogs stats users 224 * @param end the upper bound of the range of blogs stats users (not inclusive) 225 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 226 * @param retrieveFromCache whether to retrieve from the finder cache 227 * @return the ordered range of matching blogs stats users 228 */ 229 public java.util.List<BlogsStatsUser> findByUserId(long userId, int start, 230 int end, 231 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator, 232 boolean retrieveFromCache); 233 234 /** 235 * Returns the first blogs stats user in the ordered set where userId = ?. 236 * 237 * @param userId the user ID 238 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 239 * @return the first matching blogs stats user 240 * @throws NoSuchStatsUserException if a matching blogs stats user could not be found 241 */ 242 public BlogsStatsUser findByUserId_First(long userId, 243 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator) 244 throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException; 245 246 /** 247 * Returns the first blogs stats user in the ordered set where userId = ?. 248 * 249 * @param userId the user ID 250 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 251 * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found 252 */ 253 public BlogsStatsUser fetchByUserId_First(long userId, 254 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator); 255 256 /** 257 * Returns the last blogs stats user in the ordered set where userId = ?. 258 * 259 * @param userId the user ID 260 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 261 * @return the last matching blogs stats user 262 * @throws NoSuchStatsUserException if a matching blogs stats user could not be found 263 */ 264 public BlogsStatsUser findByUserId_Last(long userId, 265 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator) 266 throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException; 267 268 /** 269 * Returns the last blogs stats user in the ordered set where userId = ?. 270 * 271 * @param userId the user ID 272 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 273 * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found 274 */ 275 public BlogsStatsUser fetchByUserId_Last(long userId, 276 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator); 277 278 /** 279 * Returns the blogs stats users before and after the current blogs stats user in the ordered set where userId = ?. 280 * 281 * @param statsUserId the primary key of the current blogs stats user 282 * @param userId the user ID 283 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 284 * @return the previous, current, and next blogs stats user 285 * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found 286 */ 287 public BlogsStatsUser[] findByUserId_PrevAndNext(long statsUserId, 288 long userId, 289 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator) 290 throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException; 291 292 /** 293 * Removes all the blogs stats users where userId = ? from the database. 294 * 295 * @param userId the user ID 296 */ 297 public void removeByUserId(long userId); 298 299 /** 300 * Returns the number of blogs stats users where userId = ?. 301 * 302 * @param userId the user ID 303 * @return the number of matching blogs stats users 304 */ 305 public int countByUserId(long userId); 306 307 /** 308 * Returns the blogs stats user where groupId = ? and userId = ? or throws a {@link NoSuchStatsUserException} if it could not be found. 309 * 310 * @param groupId the group ID 311 * @param userId the user ID 312 * @return the matching blogs stats user 313 * @throws NoSuchStatsUserException if a matching blogs stats user could not be found 314 */ 315 public BlogsStatsUser findByG_U(long groupId, long userId) 316 throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException; 317 318 /** 319 * Returns the blogs stats user where groupId = ? and userId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 320 * 321 * @param groupId the group ID 322 * @param userId the user ID 323 * @return the matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found 324 */ 325 public BlogsStatsUser fetchByG_U(long groupId, long userId); 326 327 /** 328 * Returns the blogs stats user where groupId = ? and userId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 329 * 330 * @param groupId the group ID 331 * @param userId the user ID 332 * @param retrieveFromCache whether to retrieve from the finder cache 333 * @return the matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found 334 */ 335 public BlogsStatsUser fetchByG_U(long groupId, long userId, 336 boolean retrieveFromCache); 337 338 /** 339 * Removes the blogs stats user where groupId = ? and userId = ? from the database. 340 * 341 * @param groupId the group ID 342 * @param userId the user ID 343 * @return the blogs stats user that was removed 344 */ 345 public BlogsStatsUser removeByG_U(long groupId, long userId) 346 throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException; 347 348 /** 349 * Returns the number of blogs stats users where groupId = ? and userId = ?. 350 * 351 * @param groupId the group ID 352 * @param userId the user ID 353 * @return the number of matching blogs stats users 354 */ 355 public int countByG_U(long groupId, long userId); 356 357 /** 358 * Returns all the blogs stats users where groupId = ? and entryCount ≠ ?. 359 * 360 * @param groupId the group ID 361 * @param entryCount the entry count 362 * @return the matching blogs stats users 363 */ 364 public java.util.List<BlogsStatsUser> findByG_NotE(long groupId, 365 int entryCount); 366 367 /** 368 * Returns a range of all the blogs stats users where groupId = ? and entryCount ≠ ?. 369 * 370 * <p> 371 * 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. 372 * </p> 373 * 374 * @param groupId the group ID 375 * @param entryCount the entry count 376 * @param start the lower bound of the range of blogs stats users 377 * @param end the upper bound of the range of blogs stats users (not inclusive) 378 * @return the range of matching blogs stats users 379 */ 380 public java.util.List<BlogsStatsUser> findByG_NotE(long groupId, 381 int entryCount, int start, int end); 382 383 /** 384 * Returns an ordered range of all the blogs stats users where groupId = ? and entryCount ≠ ?. 385 * 386 * <p> 387 * 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. 388 * </p> 389 * 390 * @param groupId the group ID 391 * @param entryCount the entry count 392 * @param start the lower bound of the range of blogs stats users 393 * @param end the upper bound of the range of blogs stats users (not inclusive) 394 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 395 * @return the ordered range of matching blogs stats users 396 */ 397 public java.util.List<BlogsStatsUser> findByG_NotE(long groupId, 398 int entryCount, int start, int end, 399 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator); 400 401 /** 402 * Returns an ordered range of all the blogs stats users where groupId = ? and entryCount ≠ ?. 403 * 404 * <p> 405 * 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. 406 * </p> 407 * 408 * @param groupId the group ID 409 * @param entryCount the entry count 410 * @param start the lower bound of the range of blogs stats users 411 * @param end the upper bound of the range of blogs stats users (not inclusive) 412 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 413 * @param retrieveFromCache whether to retrieve from the finder cache 414 * @return the ordered range of matching blogs stats users 415 */ 416 public java.util.List<BlogsStatsUser> findByG_NotE(long groupId, 417 int entryCount, int start, int end, 418 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator, 419 boolean retrieveFromCache); 420 421 /** 422 * Returns the first blogs stats user in the ordered set where groupId = ? and entryCount ≠ ?. 423 * 424 * @param groupId the group ID 425 * @param entryCount the entry count 426 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 427 * @return the first matching blogs stats user 428 * @throws NoSuchStatsUserException if a matching blogs stats user could not be found 429 */ 430 public BlogsStatsUser findByG_NotE_First(long groupId, int entryCount, 431 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator) 432 throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException; 433 434 /** 435 * Returns the first blogs stats user in the ordered set where groupId = ? and entryCount ≠ ?. 436 * 437 * @param groupId the group ID 438 * @param entryCount the entry count 439 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 440 * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found 441 */ 442 public BlogsStatsUser fetchByG_NotE_First(long groupId, int entryCount, 443 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator); 444 445 /** 446 * Returns the last blogs stats user in the ordered set where groupId = ? and entryCount ≠ ?. 447 * 448 * @param groupId the group ID 449 * @param entryCount the entry count 450 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 451 * @return the last matching blogs stats user 452 * @throws NoSuchStatsUserException if a matching blogs stats user could not be found 453 */ 454 public BlogsStatsUser findByG_NotE_Last(long groupId, int entryCount, 455 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator) 456 throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException; 457 458 /** 459 * Returns the last blogs stats user in the ordered set where groupId = ? and entryCount ≠ ?. 460 * 461 * @param groupId the group ID 462 * @param entryCount the entry count 463 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 464 * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found 465 */ 466 public BlogsStatsUser fetchByG_NotE_Last(long groupId, int entryCount, 467 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator); 468 469 /** 470 * Returns the blogs stats users before and after the current blogs stats user in the ordered set where groupId = ? and entryCount ≠ ?. 471 * 472 * @param statsUserId the primary key of the current blogs stats user 473 * @param groupId the group ID 474 * @param entryCount the entry count 475 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 476 * @return the previous, current, and next blogs stats user 477 * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found 478 */ 479 public BlogsStatsUser[] findByG_NotE_PrevAndNext(long statsUserId, 480 long groupId, int entryCount, 481 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator) 482 throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException; 483 484 /** 485 * Removes all the blogs stats users where groupId = ? and entryCount ≠ ? from the database. 486 * 487 * @param groupId the group ID 488 * @param entryCount the entry count 489 */ 490 public void removeByG_NotE(long groupId, int entryCount); 491 492 /** 493 * Returns the number of blogs stats users where groupId = ? and entryCount ≠ ?. 494 * 495 * @param groupId the group ID 496 * @param entryCount the entry count 497 * @return the number of matching blogs stats users 498 */ 499 public int countByG_NotE(long groupId, int entryCount); 500 501 /** 502 * Returns all the blogs stats users where companyId = ? and entryCount ≠ ?. 503 * 504 * @param companyId the company ID 505 * @param entryCount the entry count 506 * @return the matching blogs stats users 507 */ 508 public java.util.List<BlogsStatsUser> findByC_NotE(long companyId, 509 int entryCount); 510 511 /** 512 * Returns a range of all the blogs stats users where companyId = ? and entryCount ≠ ?. 513 * 514 * <p> 515 * 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. 516 * </p> 517 * 518 * @param companyId the company ID 519 * @param entryCount the entry count 520 * @param start the lower bound of the range of blogs stats users 521 * @param end the upper bound of the range of blogs stats users (not inclusive) 522 * @return the range of matching blogs stats users 523 */ 524 public java.util.List<BlogsStatsUser> findByC_NotE(long companyId, 525 int entryCount, int start, int end); 526 527 /** 528 * Returns an ordered range of all the blogs stats users where companyId = ? and entryCount ≠ ?. 529 * 530 * <p> 531 * 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. 532 * </p> 533 * 534 * @param companyId the company ID 535 * @param entryCount the entry count 536 * @param start the lower bound of the range of blogs stats users 537 * @param end the upper bound of the range of blogs stats users (not inclusive) 538 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 539 * @return the ordered range of matching blogs stats users 540 */ 541 public java.util.List<BlogsStatsUser> findByC_NotE(long companyId, 542 int entryCount, int start, int end, 543 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator); 544 545 /** 546 * Returns an ordered range of all the blogs stats users where companyId = ? and entryCount ≠ ?. 547 * 548 * <p> 549 * 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. 550 * </p> 551 * 552 * @param companyId the company ID 553 * @param entryCount the entry count 554 * @param start the lower bound of the range of blogs stats users 555 * @param end the upper bound of the range of blogs stats users (not inclusive) 556 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 557 * @param retrieveFromCache whether to retrieve from the finder cache 558 * @return the ordered range of matching blogs stats users 559 */ 560 public java.util.List<BlogsStatsUser> findByC_NotE(long companyId, 561 int entryCount, int start, int end, 562 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator, 563 boolean retrieveFromCache); 564 565 /** 566 * Returns the first blogs stats user in the ordered set where companyId = ? and entryCount ≠ ?. 567 * 568 * @param companyId the company 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 NoSuchStatsUserException if a matching blogs stats user could not be found 573 */ 574 public BlogsStatsUser findByC_NotE_First(long companyId, int entryCount, 575 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator) 576 throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException; 577 578 /** 579 * Returns the first blogs stats user in the ordered set where companyId = ? and entryCount ≠ ?. 580 * 581 * @param companyId the company ID 582 * @param entryCount the entry count 583 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 584 * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found 585 */ 586 public BlogsStatsUser fetchByC_NotE_First(long companyId, int entryCount, 587 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator); 588 589 /** 590 * Returns the last blogs stats user in the ordered set where companyId = ? and entryCount ≠ ?. 591 * 592 * @param companyId the company ID 593 * @param entryCount the entry count 594 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 595 * @return the last matching blogs stats user 596 * @throws NoSuchStatsUserException if a matching blogs stats user could not be found 597 */ 598 public BlogsStatsUser findByC_NotE_Last(long companyId, int entryCount, 599 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator) 600 throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException; 601 602 /** 603 * Returns the last blogs stats user in the ordered set where companyId = ? and entryCount ≠ ?. 604 * 605 * @param companyId the company ID 606 * @param entryCount the entry count 607 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 608 * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found 609 */ 610 public BlogsStatsUser fetchByC_NotE_Last(long companyId, int entryCount, 611 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator); 612 613 /** 614 * Returns the blogs stats users before and after the current blogs stats user in the ordered set where companyId = ? and entryCount ≠ ?. 615 * 616 * @param statsUserId the primary key of the current blogs stats user 617 * @param companyId the company ID 618 * @param entryCount the entry count 619 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 620 * @return the previous, current, and next blogs stats user 621 * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found 622 */ 623 public BlogsStatsUser[] findByC_NotE_PrevAndNext(long statsUserId, 624 long companyId, int entryCount, 625 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator) 626 throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException; 627 628 /** 629 * Removes all the blogs stats users where companyId = ? and entryCount ≠ ? from the database. 630 * 631 * @param companyId the company ID 632 * @param entryCount the entry count 633 */ 634 public void removeByC_NotE(long companyId, int entryCount); 635 636 /** 637 * Returns the number of blogs stats users where companyId = ? and entryCount ≠ ?. 638 * 639 * @param companyId the company ID 640 * @param entryCount the entry count 641 * @return the number of matching blogs stats users 642 */ 643 public int countByC_NotE(long companyId, int entryCount); 644 645 /** 646 * Returns all the blogs stats users where userId = ? and lastPostDate = ?. 647 * 648 * @param userId the user ID 649 * @param lastPostDate the last post date 650 * @return the matching blogs stats users 651 */ 652 public java.util.List<BlogsStatsUser> findByU_L(long userId, 653 java.util.Date lastPostDate); 654 655 /** 656 * Returns a range of all the blogs stats users where userId = ? and lastPostDate = ?. 657 * 658 * <p> 659 * 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. 660 * </p> 661 * 662 * @param userId the user ID 663 * @param lastPostDate the last post date 664 * @param start the lower bound of the range of blogs stats users 665 * @param end the upper bound of the range of blogs stats users (not inclusive) 666 * @return the range of matching blogs stats users 667 */ 668 public java.util.List<BlogsStatsUser> findByU_L(long userId, 669 java.util.Date lastPostDate, int start, int end); 670 671 /** 672 * Returns an ordered range of all the blogs stats users where userId = ? and lastPostDate = ?. 673 * 674 * <p> 675 * 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. 676 * </p> 677 * 678 * @param userId the user ID 679 * @param lastPostDate the last post date 680 * @param start the lower bound of the range of blogs stats users 681 * @param end the upper bound of the range of blogs stats users (not inclusive) 682 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 683 * @return the ordered range of matching blogs stats users 684 */ 685 public java.util.List<BlogsStatsUser> findByU_L(long userId, 686 java.util.Date lastPostDate, int start, int end, 687 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator); 688 689 /** 690 * Returns an ordered range of all the blogs stats users where userId = ? and lastPostDate = ?. 691 * 692 * <p> 693 * 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. 694 * </p> 695 * 696 * @param userId the user ID 697 * @param lastPostDate the last post date 698 * @param start the lower bound of the range of blogs stats users 699 * @param end the upper bound of the range of blogs stats users (not inclusive) 700 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 701 * @param retrieveFromCache whether to retrieve from the finder cache 702 * @return the ordered range of matching blogs stats users 703 */ 704 public java.util.List<BlogsStatsUser> findByU_L(long userId, 705 java.util.Date lastPostDate, int start, int end, 706 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator, 707 boolean retrieveFromCache); 708 709 /** 710 * Returns the first blogs stats user in the ordered set where userId = ? and lastPostDate = ?. 711 * 712 * @param userId the user ID 713 * @param lastPostDate the last post date 714 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 715 * @return the first matching blogs stats user 716 * @throws NoSuchStatsUserException if a matching blogs stats user could not be found 717 */ 718 public BlogsStatsUser findByU_L_First(long userId, 719 java.util.Date lastPostDate, 720 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator) 721 throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException; 722 723 /** 724 * Returns the first blogs stats user in the ordered set where userId = ? and lastPostDate = ?. 725 * 726 * @param userId the user ID 727 * @param lastPostDate the last post date 728 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 729 * @return the first matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found 730 */ 731 public BlogsStatsUser fetchByU_L_First(long userId, 732 java.util.Date lastPostDate, 733 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator); 734 735 /** 736 * Returns the last blogs stats user in the ordered set where userId = ? and lastPostDate = ?. 737 * 738 * @param userId the user ID 739 * @param lastPostDate the last post date 740 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 741 * @return the last matching blogs stats user 742 * @throws NoSuchStatsUserException if a matching blogs stats user could not be found 743 */ 744 public BlogsStatsUser findByU_L_Last(long userId, 745 java.util.Date lastPostDate, 746 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator) 747 throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException; 748 749 /** 750 * Returns the last blogs stats user in the ordered set where userId = ? and lastPostDate = ?. 751 * 752 * @param userId the user ID 753 * @param lastPostDate the last post date 754 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 755 * @return the last matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found 756 */ 757 public BlogsStatsUser fetchByU_L_Last(long userId, 758 java.util.Date lastPostDate, 759 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator); 760 761 /** 762 * Returns the blogs stats users before and after the current blogs stats user in the ordered set where userId = ? and lastPostDate = ?. 763 * 764 * @param statsUserId the primary key of the current blogs stats user 765 * @param userId the user ID 766 * @param lastPostDate the last post date 767 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 768 * @return the previous, current, and next blogs stats user 769 * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found 770 */ 771 public BlogsStatsUser[] findByU_L_PrevAndNext(long statsUserId, 772 long userId, java.util.Date lastPostDate, 773 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator) 774 throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException; 775 776 /** 777 * Removes all the blogs stats users where userId = ? and lastPostDate = ? from the database. 778 * 779 * @param userId the user ID 780 * @param lastPostDate the last post date 781 */ 782 public void removeByU_L(long userId, java.util.Date lastPostDate); 783 784 /** 785 * Returns the number of blogs stats users where userId = ? and lastPostDate = ?. 786 * 787 * @param userId the user ID 788 * @param lastPostDate the last post date 789 * @return the number of matching blogs stats users 790 */ 791 public int countByU_L(long userId, java.util.Date lastPostDate); 792 793 /** 794 * Caches the blogs stats user in the entity cache if it is enabled. 795 * 796 * @param blogsStatsUser the blogs stats user 797 */ 798 public void cacheResult(BlogsStatsUser blogsStatsUser); 799 800 /** 801 * Caches the blogs stats users in the entity cache if it is enabled. 802 * 803 * @param blogsStatsUsers the blogs stats users 804 */ 805 public void cacheResult(java.util.List<BlogsStatsUser> blogsStatsUsers); 806 807 /** 808 * Creates a new blogs stats user with the primary key. Does not add the blogs stats user to the database. 809 * 810 * @param statsUserId the primary key for the new blogs stats user 811 * @return the new blogs stats user 812 */ 813 public BlogsStatsUser create(long statsUserId); 814 815 /** 816 * Removes the blogs stats user with the primary key from the database. Also notifies the appropriate model listeners. 817 * 818 * @param statsUserId the primary key of the blogs stats user 819 * @return the blogs stats user that was removed 820 * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found 821 */ 822 public BlogsStatsUser remove(long statsUserId) 823 throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException; 824 825 public BlogsStatsUser updateImpl(BlogsStatsUser blogsStatsUser); 826 827 /** 828 * Returns the blogs stats user with the primary key or throws a {@link NoSuchStatsUserException} if it could not be found. 829 * 830 * @param statsUserId the primary key of the blogs stats user 831 * @return the blogs stats user 832 * @throws NoSuchStatsUserException if a blogs stats user with the primary key could not be found 833 */ 834 public BlogsStatsUser findByPrimaryKey(long statsUserId) 835 throws com.liferay.portlet.blogs.exception.NoSuchStatsUserException; 836 837 /** 838 * Returns the blogs stats user with the primary key or returns <code>null</code> if it could not be found. 839 * 840 * @param statsUserId the primary key of the blogs stats user 841 * @return the blogs stats user, or <code>null</code> if a blogs stats user with the primary key could not be found 842 */ 843 public BlogsStatsUser fetchByPrimaryKey(long statsUserId); 844 845 @Override 846 public java.util.Map<java.io.Serializable, BlogsStatsUser> fetchByPrimaryKeys( 847 java.util.Set<java.io.Serializable> primaryKeys); 848 849 /** 850 * Returns all the blogs stats users. 851 * 852 * @return the blogs stats users 853 */ 854 public java.util.List<BlogsStatsUser> findAll(); 855 856 /** 857 * Returns a range of all the blogs stats users. 858 * 859 * <p> 860 * 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. 861 * </p> 862 * 863 * @param start the lower bound of the range of blogs stats users 864 * @param end the upper bound of the range of blogs stats users (not inclusive) 865 * @return the range of blogs stats users 866 */ 867 public java.util.List<BlogsStatsUser> findAll(int start, int end); 868 869 /** 870 * Returns an ordered range of all the blogs stats users. 871 * 872 * <p> 873 * 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. 874 * </p> 875 * 876 * @param start the lower bound of the range of blogs stats users 877 * @param end the upper bound of the range of blogs stats users (not inclusive) 878 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 879 * @return the ordered range of blogs stats users 880 */ 881 public java.util.List<BlogsStatsUser> findAll(int start, int end, 882 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator); 883 884 /** 885 * Returns an ordered range of all the blogs stats users. 886 * 887 * <p> 888 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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. 889 * </p> 890 * 891 * @param start the lower bound of the range of blogs stats users 892 * @param end the upper bound of the range of blogs stats users (not inclusive) 893 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 894 * @param retrieveFromCache whether to retrieve from the finder cache 895 * @return the ordered range of blogs stats users 896 */ 897 public java.util.List<BlogsStatsUser> findAll(int start, int end, 898 com.liferay.portal.kernel.util.OrderByComparator<BlogsStatsUser> orderByComparator, 899 boolean retrieveFromCache); 900 901 /** 902 * Removes all the blogs stats users from the database. 903 */ 904 public void removeAll(); 905 906 /** 907 * Returns the number of blogs stats users. 908 * 909 * @return the number of blogs stats users 910 */ 911 public int countAll(); 912 }