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