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