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