001 /** 002 * Copyright (c) 2000-present Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portlet.messageboards.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 020 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 021 import com.liferay.portal.kernel.util.OrderByComparator; 022 import com.liferay.portal.kernel.util.ReferenceRegistry; 023 import com.liferay.portal.service.ServiceContext; 024 025 import com.liferay.portlet.messageboards.model.MBStatsUser; 026 027 import java.util.List; 028 029 /** 030 * The persistence utility for the message boards stats user service. This utility wraps {@link MBStatsUserPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 031 * 032 * <p> 033 * Caching information and settings can be found in <code>portal.properties</code> 034 * </p> 035 * 036 * @author Brian Wing Shun Chan 037 * @see MBStatsUserPersistence 038 * @see MBStatsUserPersistenceImpl 039 * @generated 040 */ 041 @ProviderType 042 public class MBStatsUserUtil { 043 /* 044 * NOTE FOR DEVELOPERS: 045 * 046 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 047 */ 048 049 /** 050 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 051 */ 052 public static void clearCache() { 053 getPersistence().clearCache(); 054 } 055 056 /** 057 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 058 */ 059 public static void clearCache(MBStatsUser mbStatsUser) { 060 getPersistence().clearCache(mbStatsUser); 061 } 062 063 /** 064 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 065 */ 066 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 067 return getPersistence().countWithDynamicQuery(dynamicQuery); 068 } 069 070 /** 071 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 072 */ 073 public static List<MBStatsUser> findWithDynamicQuery( 074 DynamicQuery dynamicQuery) { 075 return getPersistence().findWithDynamicQuery(dynamicQuery); 076 } 077 078 /** 079 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 080 */ 081 public static List<MBStatsUser> findWithDynamicQuery( 082 DynamicQuery dynamicQuery, int start, int end) { 083 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 084 } 085 086 /** 087 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 088 */ 089 public static List<MBStatsUser> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator<MBStatsUser> orderByComparator) { 092 return getPersistence() 093 .findWithDynamicQuery(dynamicQuery, start, end, 094 orderByComparator); 095 } 096 097 /** 098 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 099 */ 100 public static MBStatsUser update(MBStatsUser mbStatsUser) { 101 return getPersistence().update(mbStatsUser); 102 } 103 104 /** 105 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 106 */ 107 public static MBStatsUser update(MBStatsUser mbStatsUser, 108 ServiceContext serviceContext) { 109 return getPersistence().update(mbStatsUser, serviceContext); 110 } 111 112 /** 113 * Returns all the message boards stats users where groupId = ?. 114 * 115 * @param groupId the group ID 116 * @return the matching message boards stats users 117 */ 118 public static java.util.List<com.liferay.portlet.messageboards.model.MBStatsUser> findByGroupId( 119 long groupId) { 120 return getPersistence().findByGroupId(groupId); 121 } 122 123 /** 124 * Returns a range of all the message boards stats users where groupId = ?. 125 * 126 * <p> 127 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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.messageboards.model.impl.MBStatsUserModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 128 * </p> 129 * 130 * @param groupId the group ID 131 * @param start the lower bound of the range of message boards stats users 132 * @param end the upper bound of the range of message boards stats users (not inclusive) 133 * @return the range of matching message boards stats users 134 */ 135 public static java.util.List<com.liferay.portlet.messageboards.model.MBStatsUser> findByGroupId( 136 long groupId, int start, int end) { 137 return getPersistence().findByGroupId(groupId, start, end); 138 } 139 140 /** 141 * Returns an ordered range of all the message boards stats users where groupId = ?. 142 * 143 * <p> 144 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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.messageboards.model.impl.MBStatsUserModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 145 * </p> 146 * 147 * @param groupId the group ID 148 * @param start the lower bound of the range of message boards stats users 149 * @param end the upper bound of the range of message boards stats users (not inclusive) 150 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 151 * @return the ordered range of matching message boards stats users 152 */ 153 public static java.util.List<com.liferay.portlet.messageboards.model.MBStatsUser> findByGroupId( 154 long groupId, int start, int end, 155 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBStatsUser> orderByComparator) { 156 return getPersistence() 157 .findByGroupId(groupId, start, end, orderByComparator); 158 } 159 160 /** 161 * Returns the first message boards stats user in the ordered set where groupId = ?. 162 * 163 * @param groupId the group ID 164 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 165 * @return the first matching message boards stats user 166 * @throws com.liferay.portlet.messageboards.NoSuchStatsUserException if a matching message boards stats user could not be found 167 */ 168 public static com.liferay.portlet.messageboards.model.MBStatsUser findByGroupId_First( 169 long groupId, 170 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBStatsUser> orderByComparator) 171 throws com.liferay.portlet.messageboards.NoSuchStatsUserException { 172 return getPersistence().findByGroupId_First(groupId, orderByComparator); 173 } 174 175 /** 176 * Returns the first message boards stats user in the ordered set where groupId = ?. 177 * 178 * @param groupId the group ID 179 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 180 * @return the first matching message boards stats user, or <code>null</code> if a matching message boards stats user could not be found 181 */ 182 public static com.liferay.portlet.messageboards.model.MBStatsUser fetchByGroupId_First( 183 long groupId, 184 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBStatsUser> orderByComparator) { 185 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 186 } 187 188 /** 189 * Returns the last message boards stats user in the ordered set where groupId = ?. 190 * 191 * @param groupId the group ID 192 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 193 * @return the last matching message boards stats user 194 * @throws com.liferay.portlet.messageboards.NoSuchStatsUserException if a matching message boards stats user could not be found 195 */ 196 public static com.liferay.portlet.messageboards.model.MBStatsUser findByGroupId_Last( 197 long groupId, 198 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBStatsUser> orderByComparator) 199 throws com.liferay.portlet.messageboards.NoSuchStatsUserException { 200 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 201 } 202 203 /** 204 * Returns the last message boards stats user in the ordered set where groupId = ?. 205 * 206 * @param groupId the group ID 207 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 208 * @return the last matching message boards stats user, or <code>null</code> if a matching message boards stats user could not be found 209 */ 210 public static com.liferay.portlet.messageboards.model.MBStatsUser fetchByGroupId_Last( 211 long groupId, 212 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBStatsUser> orderByComparator) { 213 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 214 } 215 216 /** 217 * Returns the message boards stats users before and after the current message boards stats user in the ordered set where groupId = ?. 218 * 219 * @param statsUserId the primary key of the current message boards stats user 220 * @param groupId the group ID 221 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 222 * @return the previous, current, and next message boards stats user 223 * @throws com.liferay.portlet.messageboards.NoSuchStatsUserException if a message boards stats user with the primary key could not be found 224 */ 225 public static com.liferay.portlet.messageboards.model.MBStatsUser[] findByGroupId_PrevAndNext( 226 long statsUserId, long groupId, 227 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBStatsUser> orderByComparator) 228 throws com.liferay.portlet.messageboards.NoSuchStatsUserException { 229 return getPersistence() 230 .findByGroupId_PrevAndNext(statsUserId, groupId, 231 orderByComparator); 232 } 233 234 /** 235 * Removes all the message boards stats users where groupId = ? from the database. 236 * 237 * @param groupId the group ID 238 */ 239 public static void removeByGroupId(long groupId) { 240 getPersistence().removeByGroupId(groupId); 241 } 242 243 /** 244 * Returns the number of message boards stats users where groupId = ?. 245 * 246 * @param groupId the group ID 247 * @return the number of matching message boards stats users 248 */ 249 public static int countByGroupId(long groupId) { 250 return getPersistence().countByGroupId(groupId); 251 } 252 253 /** 254 * Returns all the message boards stats users where userId = ?. 255 * 256 * @param userId the user ID 257 * @return the matching message boards stats users 258 */ 259 public static java.util.List<com.liferay.portlet.messageboards.model.MBStatsUser> findByUserId( 260 long userId) { 261 return getPersistence().findByUserId(userId); 262 } 263 264 /** 265 * Returns a range of all the message boards stats users where userId = ?. 266 * 267 * <p> 268 * 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.messageboards.model.impl.MBStatsUserModelImpl}. 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. 269 * </p> 270 * 271 * @param userId the user ID 272 * @param start the lower bound of the range of message boards stats users 273 * @param end the upper bound of the range of message boards stats users (not inclusive) 274 * @return the range of matching message boards stats users 275 */ 276 public static java.util.List<com.liferay.portlet.messageboards.model.MBStatsUser> findByUserId( 277 long userId, int start, int end) { 278 return getPersistence().findByUserId(userId, start, end); 279 } 280 281 /** 282 * Returns an ordered range of all the message boards stats users where userId = ?. 283 * 284 * <p> 285 * 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.messageboards.model.impl.MBStatsUserModelImpl}. 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. 286 * </p> 287 * 288 * @param userId the user ID 289 * @param start the lower bound of the range of message boards stats users 290 * @param end the upper bound of the range of message boards stats users (not inclusive) 291 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 292 * @return the ordered range of matching message boards stats users 293 */ 294 public static java.util.List<com.liferay.portlet.messageboards.model.MBStatsUser> findByUserId( 295 long userId, int start, int end, 296 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBStatsUser> orderByComparator) { 297 return getPersistence() 298 .findByUserId(userId, start, end, orderByComparator); 299 } 300 301 /** 302 * Returns the first message boards stats user in the ordered set where userId = ?. 303 * 304 * @param userId the user ID 305 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 306 * @return the first matching message boards stats user 307 * @throws com.liferay.portlet.messageboards.NoSuchStatsUserException if a matching message boards stats user could not be found 308 */ 309 public static com.liferay.portlet.messageboards.model.MBStatsUser findByUserId_First( 310 long userId, 311 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBStatsUser> orderByComparator) 312 throws com.liferay.portlet.messageboards.NoSuchStatsUserException { 313 return getPersistence().findByUserId_First(userId, orderByComparator); 314 } 315 316 /** 317 * Returns the first message boards stats user in the ordered set where userId = ?. 318 * 319 * @param userId the user ID 320 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 321 * @return the first matching message boards stats user, or <code>null</code> if a matching message boards stats user could not be found 322 */ 323 public static com.liferay.portlet.messageboards.model.MBStatsUser fetchByUserId_First( 324 long userId, 325 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBStatsUser> orderByComparator) { 326 return getPersistence().fetchByUserId_First(userId, orderByComparator); 327 } 328 329 /** 330 * Returns the last message boards stats user in the ordered set where userId = ?. 331 * 332 * @param userId the user ID 333 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 334 * @return the last matching message boards stats user 335 * @throws com.liferay.portlet.messageboards.NoSuchStatsUserException if a matching message boards stats user could not be found 336 */ 337 public static com.liferay.portlet.messageboards.model.MBStatsUser findByUserId_Last( 338 long userId, 339 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBStatsUser> orderByComparator) 340 throws com.liferay.portlet.messageboards.NoSuchStatsUserException { 341 return getPersistence().findByUserId_Last(userId, orderByComparator); 342 } 343 344 /** 345 * Returns the last message boards 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 last matching message boards stats user, or <code>null</code> if a matching message boards stats user could not be found 350 */ 351 public static com.liferay.portlet.messageboards.model.MBStatsUser fetchByUserId_Last( 352 long userId, 353 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBStatsUser> orderByComparator) { 354 return getPersistence().fetchByUserId_Last(userId, orderByComparator); 355 } 356 357 /** 358 * Returns the message boards stats users before and after the current message boards stats user in the ordered set where userId = ?. 359 * 360 * @param statsUserId the primary key of the current message boards stats user 361 * @param userId the user ID 362 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 363 * @return the previous, current, and next message boards stats user 364 * @throws com.liferay.portlet.messageboards.NoSuchStatsUserException if a message boards stats user with the primary key could not be found 365 */ 366 public static com.liferay.portlet.messageboards.model.MBStatsUser[] findByUserId_PrevAndNext( 367 long statsUserId, long userId, 368 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBStatsUser> orderByComparator) 369 throws com.liferay.portlet.messageboards.NoSuchStatsUserException { 370 return getPersistence() 371 .findByUserId_PrevAndNext(statsUserId, userId, 372 orderByComparator); 373 } 374 375 /** 376 * Removes all the message boards stats users where userId = ? from the database. 377 * 378 * @param userId the user ID 379 */ 380 public static void removeByUserId(long userId) { 381 getPersistence().removeByUserId(userId); 382 } 383 384 /** 385 * Returns the number of message boards stats users where userId = ?. 386 * 387 * @param userId the user ID 388 * @return the number of matching message boards stats users 389 */ 390 public static int countByUserId(long userId) { 391 return getPersistence().countByUserId(userId); 392 } 393 394 /** 395 * Returns the message boards stats user where groupId = ? and userId = ? or throws a {@link com.liferay.portlet.messageboards.NoSuchStatsUserException} if it could not be found. 396 * 397 * @param groupId the group ID 398 * @param userId the user ID 399 * @return the matching message boards stats user 400 * @throws com.liferay.portlet.messageboards.NoSuchStatsUserException if a matching message boards stats user could not be found 401 */ 402 public static com.liferay.portlet.messageboards.model.MBStatsUser findByG_U( 403 long groupId, long userId) 404 throws com.liferay.portlet.messageboards.NoSuchStatsUserException { 405 return getPersistence().findByG_U(groupId, userId); 406 } 407 408 /** 409 * Returns the message boards stats user where groupId = ? and userId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 410 * 411 * @param groupId the group ID 412 * @param userId the user ID 413 * @return the matching message boards stats user, or <code>null</code> if a matching message boards stats user could not be found 414 */ 415 public static com.liferay.portlet.messageboards.model.MBStatsUser fetchByG_U( 416 long groupId, long userId) { 417 return getPersistence().fetchByG_U(groupId, userId); 418 } 419 420 /** 421 * Returns the message boards stats user where groupId = ? and userId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 422 * 423 * @param groupId the group ID 424 * @param userId the user ID 425 * @param retrieveFromCache whether to use the finder cache 426 * @return the matching message boards stats user, or <code>null</code> if a matching message boards stats user could not be found 427 */ 428 public static com.liferay.portlet.messageboards.model.MBStatsUser fetchByG_U( 429 long groupId, long userId, boolean retrieveFromCache) { 430 return getPersistence().fetchByG_U(groupId, userId, retrieveFromCache); 431 } 432 433 /** 434 * Removes the message boards stats user where groupId = ? and userId = ? from the database. 435 * 436 * @param groupId the group ID 437 * @param userId the user ID 438 * @return the message boards stats user that was removed 439 */ 440 public static com.liferay.portlet.messageboards.model.MBStatsUser removeByG_U( 441 long groupId, long userId) 442 throws com.liferay.portlet.messageboards.NoSuchStatsUserException { 443 return getPersistence().removeByG_U(groupId, userId); 444 } 445 446 /** 447 * Returns the number of message boards stats users where groupId = ? and userId = ?. 448 * 449 * @param groupId the group ID 450 * @param userId the user ID 451 * @return the number of matching message boards stats users 452 */ 453 public static int countByG_U(long groupId, long userId) { 454 return getPersistence().countByG_U(groupId, userId); 455 } 456 457 /** 458 * Returns all the message boards stats users where groupId = ? and userId ≠ ? and messageCount ≠ ?. 459 * 460 * @param groupId the group ID 461 * @param userId the user ID 462 * @param messageCount the message count 463 * @return the matching message boards stats users 464 */ 465 public static java.util.List<com.liferay.portlet.messageboards.model.MBStatsUser> findByG_NotU_NotM( 466 long groupId, long userId, int messageCount) { 467 return getPersistence().findByG_NotU_NotM(groupId, userId, messageCount); 468 } 469 470 /** 471 * Returns a range of all the message boards stats users where groupId = ? and userId ≠ ? and messageCount ≠ ?. 472 * 473 * <p> 474 * 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.messageboards.model.impl.MBStatsUserModelImpl}. 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. 475 * </p> 476 * 477 * @param groupId the group ID 478 * @param userId the user ID 479 * @param messageCount the message count 480 * @param start the lower bound of the range of message boards stats users 481 * @param end the upper bound of the range of message boards stats users (not inclusive) 482 * @return the range of matching message boards stats users 483 */ 484 public static java.util.List<com.liferay.portlet.messageboards.model.MBStatsUser> findByG_NotU_NotM( 485 long groupId, long userId, int messageCount, int start, int end) { 486 return getPersistence() 487 .findByG_NotU_NotM(groupId, userId, messageCount, start, end); 488 } 489 490 /** 491 * Returns an ordered range of all the message boards stats users where groupId = ? and userId ≠ ? and messageCount ≠ ?. 492 * 493 * <p> 494 * 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.messageboards.model.impl.MBStatsUserModelImpl}. 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. 495 * </p> 496 * 497 * @param groupId the group ID 498 * @param userId the user ID 499 * @param messageCount the message count 500 * @param start the lower bound of the range of message boards stats users 501 * @param end the upper bound of the range of message boards stats users (not inclusive) 502 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 503 * @return the ordered range of matching message boards stats users 504 */ 505 public static java.util.List<com.liferay.portlet.messageboards.model.MBStatsUser> findByG_NotU_NotM( 506 long groupId, long userId, int messageCount, int start, int end, 507 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBStatsUser> orderByComparator) { 508 return getPersistence() 509 .findByG_NotU_NotM(groupId, userId, messageCount, start, 510 end, orderByComparator); 511 } 512 513 /** 514 * Returns the first message boards stats user in the ordered set where groupId = ? and userId ≠ ? and messageCount ≠ ?. 515 * 516 * @param groupId the group ID 517 * @param userId the user ID 518 * @param messageCount the message count 519 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 520 * @return the first matching message boards stats user 521 * @throws com.liferay.portlet.messageboards.NoSuchStatsUserException if a matching message boards stats user could not be found 522 */ 523 public static com.liferay.portlet.messageboards.model.MBStatsUser findByG_NotU_NotM_First( 524 long groupId, long userId, int messageCount, 525 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBStatsUser> orderByComparator) 526 throws com.liferay.portlet.messageboards.NoSuchStatsUserException { 527 return getPersistence() 528 .findByG_NotU_NotM_First(groupId, userId, messageCount, 529 orderByComparator); 530 } 531 532 /** 533 * Returns the first message boards stats user in the ordered set where groupId = ? and userId ≠ ? and messageCount ≠ ?. 534 * 535 * @param groupId the group ID 536 * @param userId the user ID 537 * @param messageCount the message count 538 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 539 * @return the first matching message boards stats user, or <code>null</code> if a matching message boards stats user could not be found 540 */ 541 public static com.liferay.portlet.messageboards.model.MBStatsUser fetchByG_NotU_NotM_First( 542 long groupId, long userId, int messageCount, 543 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBStatsUser> orderByComparator) { 544 return getPersistence() 545 .fetchByG_NotU_NotM_First(groupId, userId, messageCount, 546 orderByComparator); 547 } 548 549 /** 550 * Returns the last message boards stats user in the ordered set where groupId = ? and userId ≠ ? and messageCount ≠ ?. 551 * 552 * @param groupId the group ID 553 * @param userId the user ID 554 * @param messageCount the message count 555 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 556 * @return the last matching message boards stats user 557 * @throws com.liferay.portlet.messageboards.NoSuchStatsUserException if a matching message boards stats user could not be found 558 */ 559 public static com.liferay.portlet.messageboards.model.MBStatsUser findByG_NotU_NotM_Last( 560 long groupId, long userId, int messageCount, 561 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBStatsUser> orderByComparator) 562 throws com.liferay.portlet.messageboards.NoSuchStatsUserException { 563 return getPersistence() 564 .findByG_NotU_NotM_Last(groupId, userId, messageCount, 565 orderByComparator); 566 } 567 568 /** 569 * Returns the last message boards stats user in the ordered set where groupId = ? and userId ≠ ? and messageCount ≠ ?. 570 * 571 * @param groupId the group ID 572 * @param userId the user ID 573 * @param messageCount the message count 574 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 575 * @return the last matching message boards stats user, or <code>null</code> if a matching message boards stats user could not be found 576 */ 577 public static com.liferay.portlet.messageboards.model.MBStatsUser fetchByG_NotU_NotM_Last( 578 long groupId, long userId, int messageCount, 579 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBStatsUser> orderByComparator) { 580 return getPersistence() 581 .fetchByG_NotU_NotM_Last(groupId, userId, messageCount, 582 orderByComparator); 583 } 584 585 /** 586 * Returns the message boards stats users before and after the current message boards stats user in the ordered set where groupId = ? and userId ≠ ? and messageCount ≠ ?. 587 * 588 * @param statsUserId the primary key of the current message boards stats user 589 * @param groupId the group ID 590 * @param userId the user ID 591 * @param messageCount the message count 592 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 593 * @return the previous, current, and next message boards stats user 594 * @throws com.liferay.portlet.messageboards.NoSuchStatsUserException if a message boards stats user with the primary key could not be found 595 */ 596 public static com.liferay.portlet.messageboards.model.MBStatsUser[] findByG_NotU_NotM_PrevAndNext( 597 long statsUserId, long groupId, long userId, int messageCount, 598 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBStatsUser> orderByComparator) 599 throws com.liferay.portlet.messageboards.NoSuchStatsUserException { 600 return getPersistence() 601 .findByG_NotU_NotM_PrevAndNext(statsUserId, groupId, userId, 602 messageCount, orderByComparator); 603 } 604 605 /** 606 * Removes all the message boards stats users where groupId = ? and userId ≠ ? and messageCount ≠ ? from the database. 607 * 608 * @param groupId the group ID 609 * @param userId the user ID 610 * @param messageCount the message count 611 */ 612 public static void removeByG_NotU_NotM(long groupId, long userId, 613 int messageCount) { 614 getPersistence().removeByG_NotU_NotM(groupId, userId, messageCount); 615 } 616 617 /** 618 * Returns the number of message boards stats users where groupId = ? and userId ≠ ? and messageCount ≠ ?. 619 * 620 * @param groupId the group ID 621 * @param userId the user ID 622 * @param messageCount the message count 623 * @return the number of matching message boards stats users 624 */ 625 public static int countByG_NotU_NotM(long groupId, long userId, 626 int messageCount) { 627 return getPersistence().countByG_NotU_NotM(groupId, userId, messageCount); 628 } 629 630 /** 631 * Caches the message boards stats user in the entity cache if it is enabled. 632 * 633 * @param mbStatsUser the message boards stats user 634 */ 635 public static void cacheResult( 636 com.liferay.portlet.messageboards.model.MBStatsUser mbStatsUser) { 637 getPersistence().cacheResult(mbStatsUser); 638 } 639 640 /** 641 * Caches the message boards stats users in the entity cache if it is enabled. 642 * 643 * @param mbStatsUsers the message boards stats users 644 */ 645 public static void cacheResult( 646 java.util.List<com.liferay.portlet.messageboards.model.MBStatsUser> mbStatsUsers) { 647 getPersistence().cacheResult(mbStatsUsers); 648 } 649 650 /** 651 * Creates a new message boards stats user with the primary key. Does not add the message boards stats user to the database. 652 * 653 * @param statsUserId the primary key for the new message boards stats user 654 * @return the new message boards stats user 655 */ 656 public static com.liferay.portlet.messageboards.model.MBStatsUser create( 657 long statsUserId) { 658 return getPersistence().create(statsUserId); 659 } 660 661 /** 662 * Removes the message boards stats user with the primary key from the database. Also notifies the appropriate model listeners. 663 * 664 * @param statsUserId the primary key of the message boards stats user 665 * @return the message boards stats user that was removed 666 * @throws com.liferay.portlet.messageboards.NoSuchStatsUserException if a message boards stats user with the primary key could not be found 667 */ 668 public static com.liferay.portlet.messageboards.model.MBStatsUser remove( 669 long statsUserId) 670 throws com.liferay.portlet.messageboards.NoSuchStatsUserException { 671 return getPersistence().remove(statsUserId); 672 } 673 674 public static com.liferay.portlet.messageboards.model.MBStatsUser updateImpl( 675 com.liferay.portlet.messageboards.model.MBStatsUser mbStatsUser) { 676 return getPersistence().updateImpl(mbStatsUser); 677 } 678 679 /** 680 * Returns the message boards stats user with the primary key or throws a {@link com.liferay.portlet.messageboards.NoSuchStatsUserException} if it could not be found. 681 * 682 * @param statsUserId the primary key of the message boards stats user 683 * @return the message boards stats user 684 * @throws com.liferay.portlet.messageboards.NoSuchStatsUserException if a message boards stats user with the primary key could not be found 685 */ 686 public static com.liferay.portlet.messageboards.model.MBStatsUser findByPrimaryKey( 687 long statsUserId) 688 throws com.liferay.portlet.messageboards.NoSuchStatsUserException { 689 return getPersistence().findByPrimaryKey(statsUserId); 690 } 691 692 /** 693 * Returns the message boards stats user with the primary key or returns <code>null</code> if it could not be found. 694 * 695 * @param statsUserId the primary key of the message boards stats user 696 * @return the message boards stats user, or <code>null</code> if a message boards stats user with the primary key could not be found 697 */ 698 public static com.liferay.portlet.messageboards.model.MBStatsUser fetchByPrimaryKey( 699 long statsUserId) { 700 return getPersistence().fetchByPrimaryKey(statsUserId); 701 } 702 703 public static java.util.Map<java.io.Serializable, com.liferay.portlet.messageboards.model.MBStatsUser> fetchByPrimaryKeys( 704 java.util.Set<java.io.Serializable> primaryKeys) { 705 return getPersistence().fetchByPrimaryKeys(primaryKeys); 706 } 707 708 /** 709 * Returns all the message boards stats users. 710 * 711 * @return the message boards stats users 712 */ 713 public static java.util.List<com.liferay.portlet.messageboards.model.MBStatsUser> findAll() { 714 return getPersistence().findAll(); 715 } 716 717 /** 718 * Returns a range of all the message boards stats users. 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.messageboards.model.impl.MBStatsUserModelImpl}. 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 start the lower bound of the range of message boards stats users 725 * @param end the upper bound of the range of message boards stats users (not inclusive) 726 * @return the range of message boards stats users 727 */ 728 public static java.util.List<com.liferay.portlet.messageboards.model.MBStatsUser> findAll( 729 int start, int end) { 730 return getPersistence().findAll(start, end); 731 } 732 733 /** 734 * Returns an ordered range of all the message boards stats users. 735 * 736 * <p> 737 * 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.messageboards.model.impl.MBStatsUserModelImpl}. 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. 738 * </p> 739 * 740 * @param start the lower bound of the range of message boards stats users 741 * @param end the upper bound of the range of message boards stats users (not inclusive) 742 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 743 * @return the ordered range of message boards stats users 744 */ 745 public static java.util.List<com.liferay.portlet.messageboards.model.MBStatsUser> findAll( 746 int start, int end, 747 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.messageboards.model.MBStatsUser> orderByComparator) { 748 return getPersistence().findAll(start, end, orderByComparator); 749 } 750 751 /** 752 * Removes all the message boards stats users from the database. 753 */ 754 public static void removeAll() { 755 getPersistence().removeAll(); 756 } 757 758 /** 759 * Returns the number of message boards stats users. 760 * 761 * @return the number of message boards stats users 762 */ 763 public static int countAll() { 764 return getPersistence().countAll(); 765 } 766 767 public static MBStatsUserPersistence getPersistence() { 768 if (_persistence == null) { 769 _persistence = (MBStatsUserPersistence)PortalBeanLocatorUtil.locate(MBStatsUserPersistence.class.getName()); 770 771 ReferenceRegistry.registerReference(MBStatsUserUtil.class, 772 "_persistence"); 773 } 774 775 return _persistence; 776 } 777 778 /** 779 * @deprecated As of 6.2.0 780 */ 781 @Deprecated 782 public void setPersistence(MBStatsUserPersistence persistence) { 783 } 784 785 private static MBStatsUserPersistence _persistence; 786 }