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