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