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