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