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.portal.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.exception.NoSuchUserTrackerException; 020 import com.liferay.portal.model.UserTracker; 021 022 /** 023 * The persistence interface for the user tracker service. 024 * 025 * <p> 026 * Caching information and settings can be found in <code>portal.properties</code> 027 * </p> 028 * 029 * @author Brian Wing Shun Chan 030 * @see com.liferay.portal.service.persistence.impl.UserTrackerPersistenceImpl 031 * @see UserTrackerUtil 032 * @generated 033 */ 034 @ProviderType 035 public interface UserTrackerPersistence extends BasePersistence<UserTracker> { 036 /* 037 * NOTE FOR DEVELOPERS: 038 * 039 * Never modify or reference this interface directly. Always use {@link UserTrackerUtil} to access the user tracker persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 040 */ 041 042 /** 043 * Returns all the user trackers where companyId = ?. 044 * 045 * @param companyId the company ID 046 * @return the matching user trackers 047 */ 048 public java.util.List<UserTracker> findByCompanyId(long companyId); 049 050 /** 051 * Returns a range of all the user trackers where companyId = ?. 052 * 053 * <p> 054 * 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 UserTrackerModelImpl}. 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. 055 * </p> 056 * 057 * @param companyId the company ID 058 * @param start the lower bound of the range of user trackers 059 * @param end the upper bound of the range of user trackers (not inclusive) 060 * @return the range of matching user trackers 061 */ 062 public java.util.List<UserTracker> findByCompanyId(long companyId, 063 int start, int end); 064 065 /** 066 * Returns an ordered range of all the user trackers where companyId = ?. 067 * 068 * <p> 069 * 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 UserTrackerModelImpl}. 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. 070 * </p> 071 * 072 * @param companyId the company ID 073 * @param start the lower bound of the range of user trackers 074 * @param end the upper bound of the range of user trackers (not inclusive) 075 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 076 * @return the ordered range of matching user trackers 077 */ 078 public java.util.List<UserTracker> findByCompanyId(long companyId, 079 int start, int end, 080 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator); 081 082 /** 083 * Returns an ordered range of all the user trackers where companyId = ?. 084 * 085 * <p> 086 * 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 UserTrackerModelImpl}. 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. 087 * </p> 088 * 089 * @param companyId the company ID 090 * @param start the lower bound of the range of user trackers 091 * @param end the upper bound of the range of user trackers (not inclusive) 092 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 093 * @param retrieveFromCache whether to retrieve from the finder cache 094 * @return the ordered range of matching user trackers 095 */ 096 public java.util.List<UserTracker> findByCompanyId(long companyId, 097 int start, int end, 098 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator, 099 boolean retrieveFromCache); 100 101 /** 102 * Returns the first user tracker in the ordered set where companyId = ?. 103 * 104 * @param companyId the company ID 105 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 106 * @return the first matching user tracker 107 * @throws NoSuchUserTrackerException if a matching user tracker could not be found 108 */ 109 public UserTracker findByCompanyId_First(long companyId, 110 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator) 111 throws NoSuchUserTrackerException; 112 113 /** 114 * Returns the first user tracker in the ordered set where companyId = ?. 115 * 116 * @param companyId the company ID 117 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 118 * @return the first matching user tracker, or <code>null</code> if a matching user tracker could not be found 119 */ 120 public UserTracker fetchByCompanyId_First(long companyId, 121 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator); 122 123 /** 124 * Returns the last user tracker in the ordered set where companyId = ?. 125 * 126 * @param companyId the company ID 127 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 128 * @return the last matching user tracker 129 * @throws NoSuchUserTrackerException if a matching user tracker could not be found 130 */ 131 public UserTracker findByCompanyId_Last(long companyId, 132 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator) 133 throws NoSuchUserTrackerException; 134 135 /** 136 * Returns the last user tracker in the ordered set where companyId = ?. 137 * 138 * @param companyId the company ID 139 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 140 * @return the last matching user tracker, or <code>null</code> if a matching user tracker could not be found 141 */ 142 public UserTracker fetchByCompanyId_Last(long companyId, 143 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator); 144 145 /** 146 * Returns the user trackers before and after the current user tracker in the ordered set where companyId = ?. 147 * 148 * @param userTrackerId the primary key of the current user tracker 149 * @param companyId the company ID 150 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 151 * @return the previous, current, and next user tracker 152 * @throws NoSuchUserTrackerException if a user tracker with the primary key could not be found 153 */ 154 public UserTracker[] findByCompanyId_PrevAndNext(long userTrackerId, 155 long companyId, 156 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator) 157 throws NoSuchUserTrackerException; 158 159 /** 160 * Removes all the user trackers where companyId = ? from the database. 161 * 162 * @param companyId the company ID 163 */ 164 public void removeByCompanyId(long companyId); 165 166 /** 167 * Returns the number of user trackers where companyId = ?. 168 * 169 * @param companyId the company ID 170 * @return the number of matching user trackers 171 */ 172 public int countByCompanyId(long companyId); 173 174 /** 175 * Returns all the user trackers where userId = ?. 176 * 177 * @param userId the user ID 178 * @return the matching user trackers 179 */ 180 public java.util.List<UserTracker> findByUserId(long userId); 181 182 /** 183 * Returns a range of all the user trackers where userId = ?. 184 * 185 * <p> 186 * 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 UserTrackerModelImpl}. 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. 187 * </p> 188 * 189 * @param userId the user ID 190 * @param start the lower bound of the range of user trackers 191 * @param end the upper bound of the range of user trackers (not inclusive) 192 * @return the range of matching user trackers 193 */ 194 public java.util.List<UserTracker> findByUserId(long userId, int start, 195 int end); 196 197 /** 198 * Returns an ordered range of all the user trackers where userId = ?. 199 * 200 * <p> 201 * 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 UserTrackerModelImpl}. 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. 202 * </p> 203 * 204 * @param userId the user ID 205 * @param start the lower bound of the range of user trackers 206 * @param end the upper bound of the range of user trackers (not inclusive) 207 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 208 * @return the ordered range of matching user trackers 209 */ 210 public java.util.List<UserTracker> findByUserId(long userId, int start, 211 int end, 212 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator); 213 214 /** 215 * Returns an ordered range of all the user trackers where userId = ?. 216 * 217 * <p> 218 * 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 UserTrackerModelImpl}. 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. 219 * </p> 220 * 221 * @param userId the user ID 222 * @param start the lower bound of the range of user trackers 223 * @param end the upper bound of the range of user trackers (not inclusive) 224 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 225 * @param retrieveFromCache whether to retrieve from the finder cache 226 * @return the ordered range of matching user trackers 227 */ 228 public java.util.List<UserTracker> findByUserId(long userId, int start, 229 int end, 230 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator, 231 boolean retrieveFromCache); 232 233 /** 234 * Returns the first user tracker in the ordered set where userId = ?. 235 * 236 * @param userId the user ID 237 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 238 * @return the first matching user tracker 239 * @throws NoSuchUserTrackerException if a matching user tracker could not be found 240 */ 241 public UserTracker findByUserId_First(long userId, 242 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator) 243 throws NoSuchUserTrackerException; 244 245 /** 246 * Returns the first user tracker in the ordered set where userId = ?. 247 * 248 * @param userId the user ID 249 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 250 * @return the first matching user tracker, or <code>null</code> if a matching user tracker could not be found 251 */ 252 public UserTracker fetchByUserId_First(long userId, 253 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator); 254 255 /** 256 * Returns the last user tracker in the ordered set where userId = ?. 257 * 258 * @param userId the user ID 259 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 260 * @return the last matching user tracker 261 * @throws NoSuchUserTrackerException if a matching user tracker could not be found 262 */ 263 public UserTracker findByUserId_Last(long userId, 264 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator) 265 throws NoSuchUserTrackerException; 266 267 /** 268 * Returns the last user tracker in the ordered set where userId = ?. 269 * 270 * @param userId the user ID 271 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 272 * @return the last matching user tracker, or <code>null</code> if a matching user tracker could not be found 273 */ 274 public UserTracker fetchByUserId_Last(long userId, 275 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator); 276 277 /** 278 * Returns the user trackers before and after the current user tracker in the ordered set where userId = ?. 279 * 280 * @param userTrackerId the primary key of the current user tracker 281 * @param userId the user ID 282 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 283 * @return the previous, current, and next user tracker 284 * @throws NoSuchUserTrackerException if a user tracker with the primary key could not be found 285 */ 286 public UserTracker[] findByUserId_PrevAndNext(long userTrackerId, 287 long userId, 288 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator) 289 throws NoSuchUserTrackerException; 290 291 /** 292 * Removes all the user trackers where userId = ? from the database. 293 * 294 * @param userId the user ID 295 */ 296 public void removeByUserId(long userId); 297 298 /** 299 * Returns the number of user trackers where userId = ?. 300 * 301 * @param userId the user ID 302 * @return the number of matching user trackers 303 */ 304 public int countByUserId(long userId); 305 306 /** 307 * Returns all the user trackers where sessionId = ?. 308 * 309 * @param sessionId the session ID 310 * @return the matching user trackers 311 */ 312 public java.util.List<UserTracker> findBySessionId( 313 java.lang.String sessionId); 314 315 /** 316 * Returns a range of all the user trackers where sessionId = ?. 317 * 318 * <p> 319 * 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 UserTrackerModelImpl}. 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. 320 * </p> 321 * 322 * @param sessionId the session ID 323 * @param start the lower bound of the range of user trackers 324 * @param end the upper bound of the range of user trackers (not inclusive) 325 * @return the range of matching user trackers 326 */ 327 public java.util.List<UserTracker> findBySessionId( 328 java.lang.String sessionId, int start, int end); 329 330 /** 331 * Returns an ordered range of all the user trackers where sessionId = ?. 332 * 333 * <p> 334 * 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 UserTrackerModelImpl}. 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. 335 * </p> 336 * 337 * @param sessionId the session ID 338 * @param start the lower bound of the range of user trackers 339 * @param end the upper bound of the range of user trackers (not inclusive) 340 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 341 * @return the ordered range of matching user trackers 342 */ 343 public java.util.List<UserTracker> findBySessionId( 344 java.lang.String sessionId, int start, int end, 345 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator); 346 347 /** 348 * Returns an ordered range of all the user trackers where sessionId = ?. 349 * 350 * <p> 351 * 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 UserTrackerModelImpl}. 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. 352 * </p> 353 * 354 * @param sessionId the session ID 355 * @param start the lower bound of the range of user trackers 356 * @param end the upper bound of the range of user trackers (not inclusive) 357 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 358 * @param retrieveFromCache whether to retrieve from the finder cache 359 * @return the ordered range of matching user trackers 360 */ 361 public java.util.List<UserTracker> findBySessionId( 362 java.lang.String sessionId, int start, int end, 363 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator, 364 boolean retrieveFromCache); 365 366 /** 367 * Returns the first user tracker in the ordered set where sessionId = ?. 368 * 369 * @param sessionId the session ID 370 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 371 * @return the first matching user tracker 372 * @throws NoSuchUserTrackerException if a matching user tracker could not be found 373 */ 374 public UserTracker findBySessionId_First(java.lang.String sessionId, 375 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator) 376 throws NoSuchUserTrackerException; 377 378 /** 379 * Returns the first user tracker in the ordered set where sessionId = ?. 380 * 381 * @param sessionId the session ID 382 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 383 * @return the first matching user tracker, or <code>null</code> if a matching user tracker could not be found 384 */ 385 public UserTracker fetchBySessionId_First(java.lang.String sessionId, 386 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator); 387 388 /** 389 * Returns the last user tracker in the ordered set where sessionId = ?. 390 * 391 * @param sessionId the session ID 392 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 393 * @return the last matching user tracker 394 * @throws NoSuchUserTrackerException if a matching user tracker could not be found 395 */ 396 public UserTracker findBySessionId_Last(java.lang.String sessionId, 397 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator) 398 throws NoSuchUserTrackerException; 399 400 /** 401 * Returns the last user tracker in the ordered set where sessionId = ?. 402 * 403 * @param sessionId the session ID 404 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 405 * @return the last matching user tracker, or <code>null</code> if a matching user tracker could not be found 406 */ 407 public UserTracker fetchBySessionId_Last(java.lang.String sessionId, 408 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator); 409 410 /** 411 * Returns the user trackers before and after the current user tracker in the ordered set where sessionId = ?. 412 * 413 * @param userTrackerId the primary key of the current user tracker 414 * @param sessionId the session ID 415 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 416 * @return the previous, current, and next user tracker 417 * @throws NoSuchUserTrackerException if a user tracker with the primary key could not be found 418 */ 419 public UserTracker[] findBySessionId_PrevAndNext(long userTrackerId, 420 java.lang.String sessionId, 421 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator) 422 throws NoSuchUserTrackerException; 423 424 /** 425 * Removes all the user trackers where sessionId = ? from the database. 426 * 427 * @param sessionId the session ID 428 */ 429 public void removeBySessionId(java.lang.String sessionId); 430 431 /** 432 * Returns the number of user trackers where sessionId = ?. 433 * 434 * @param sessionId the session ID 435 * @return the number of matching user trackers 436 */ 437 public int countBySessionId(java.lang.String sessionId); 438 439 /** 440 * Caches the user tracker in the entity cache if it is enabled. 441 * 442 * @param userTracker the user tracker 443 */ 444 public void cacheResult(UserTracker userTracker); 445 446 /** 447 * Caches the user trackers in the entity cache if it is enabled. 448 * 449 * @param userTrackers the user trackers 450 */ 451 public void cacheResult(java.util.List<UserTracker> userTrackers); 452 453 /** 454 * Creates a new user tracker with the primary key. Does not add the user tracker to the database. 455 * 456 * @param userTrackerId the primary key for the new user tracker 457 * @return the new user tracker 458 */ 459 public UserTracker create(long userTrackerId); 460 461 /** 462 * Removes the user tracker with the primary key from the database. Also notifies the appropriate model listeners. 463 * 464 * @param userTrackerId the primary key of the user tracker 465 * @return the user tracker that was removed 466 * @throws NoSuchUserTrackerException if a user tracker with the primary key could not be found 467 */ 468 public UserTracker remove(long userTrackerId) 469 throws NoSuchUserTrackerException; 470 471 public UserTracker updateImpl(UserTracker userTracker); 472 473 /** 474 * Returns the user tracker with the primary key or throws a {@link NoSuchUserTrackerException} if it could not be found. 475 * 476 * @param userTrackerId the primary key of the user tracker 477 * @return the user tracker 478 * @throws NoSuchUserTrackerException if a user tracker with the primary key could not be found 479 */ 480 public UserTracker findByPrimaryKey(long userTrackerId) 481 throws NoSuchUserTrackerException; 482 483 /** 484 * Returns the user tracker with the primary key or returns <code>null</code> if it could not be found. 485 * 486 * @param userTrackerId the primary key of the user tracker 487 * @return the user tracker, or <code>null</code> if a user tracker with the primary key could not be found 488 */ 489 public UserTracker fetchByPrimaryKey(long userTrackerId); 490 491 @Override 492 public java.util.Map<java.io.Serializable, UserTracker> fetchByPrimaryKeys( 493 java.util.Set<java.io.Serializable> primaryKeys); 494 495 /** 496 * Returns all the user trackers. 497 * 498 * @return the user trackers 499 */ 500 public java.util.List<UserTracker> findAll(); 501 502 /** 503 * Returns a range of all the user trackers. 504 * 505 * <p> 506 * 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 UserTrackerModelImpl}. 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. 507 * </p> 508 * 509 * @param start the lower bound of the range of user trackers 510 * @param end the upper bound of the range of user trackers (not inclusive) 511 * @return the range of user trackers 512 */ 513 public java.util.List<UserTracker> findAll(int start, int end); 514 515 /** 516 * Returns an ordered range of all the user trackers. 517 * 518 * <p> 519 * 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 UserTrackerModelImpl}. 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. 520 * </p> 521 * 522 * @param start the lower bound of the range of user trackers 523 * @param end the upper bound of the range of user trackers (not inclusive) 524 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 525 * @return the ordered range of user trackers 526 */ 527 public java.util.List<UserTracker> findAll(int start, int end, 528 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator); 529 530 /** 531 * Returns an ordered range of all the user trackers. 532 * 533 * <p> 534 * 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 UserTrackerModelImpl}. 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. 535 * </p> 536 * 537 * @param start the lower bound of the range of user trackers 538 * @param end the upper bound of the range of user trackers (not inclusive) 539 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 540 * @param retrieveFromCache whether to retrieve from the finder cache 541 * @return the ordered range of user trackers 542 */ 543 public java.util.List<UserTracker> findAll(int start, int end, 544 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator, 545 boolean retrieveFromCache); 546 547 /** 548 * Removes all the user trackers from the database. 549 */ 550 public void removeAll(); 551 552 /** 553 * Returns the number of user trackers. 554 * 555 * @return the number of user trackers 556 */ 557 public int countAll(); 558 }