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