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 the first user tracker in the ordered set where companyId = ?. 083 * 084 * @param companyId the company ID 085 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 086 * @return the first matching user tracker 087 * @throws NoSuchUserTrackerException if a matching user tracker could not be found 088 */ 089 public UserTracker findByCompanyId_First(long companyId, 090 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator) 091 throws com.liferay.portal.NoSuchUserTrackerException; 092 093 /** 094 * Returns the first user tracker in the ordered set where companyId = ?. 095 * 096 * @param companyId the company ID 097 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 098 * @return the first matching user tracker, or <code>null</code> if a matching user tracker could not be found 099 */ 100 public UserTracker fetchByCompanyId_First(long companyId, 101 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator); 102 103 /** 104 * Returns the last user tracker in the ordered set where companyId = ?. 105 * 106 * @param companyId the company ID 107 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 108 * @return the last matching user tracker 109 * @throws NoSuchUserTrackerException if a matching user tracker could not be found 110 */ 111 public UserTracker findByCompanyId_Last(long companyId, 112 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator) 113 throws com.liferay.portal.NoSuchUserTrackerException; 114 115 /** 116 * Returns the last user tracker in the ordered set where companyId = ?. 117 * 118 * @param companyId the company ID 119 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 120 * @return the last matching user tracker, or <code>null</code> if a matching user tracker could not be found 121 */ 122 public UserTracker fetchByCompanyId_Last(long companyId, 123 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator); 124 125 /** 126 * Returns the user trackers before and after the current user tracker in the ordered set where companyId = ?. 127 * 128 * @param userTrackerId the primary key of the current user tracker 129 * @param companyId the company ID 130 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 131 * @return the previous, current, and next user tracker 132 * @throws NoSuchUserTrackerException if a user tracker with the primary key could not be found 133 */ 134 public UserTracker[] findByCompanyId_PrevAndNext(long userTrackerId, 135 long companyId, 136 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator) 137 throws com.liferay.portal.NoSuchUserTrackerException; 138 139 /** 140 * Removes all the user trackers where companyId = ? from the database. 141 * 142 * @param companyId the company ID 143 */ 144 public void removeByCompanyId(long companyId); 145 146 /** 147 * Returns the number of user trackers where companyId = ?. 148 * 149 * @param companyId the company ID 150 * @return the number of matching user trackers 151 */ 152 public int countByCompanyId(long companyId); 153 154 /** 155 * Returns all the user trackers where userId = ?. 156 * 157 * @param userId the user ID 158 * @return the matching user trackers 159 */ 160 public java.util.List<UserTracker> findByUserId(long userId); 161 162 /** 163 * Returns a range of all the user trackers where userId = ?. 164 * 165 * <p> 166 * 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. 167 * </p> 168 * 169 * @param userId the user ID 170 * @param start the lower bound of the range of user trackers 171 * @param end the upper bound of the range of user trackers (not inclusive) 172 * @return the range of matching user trackers 173 */ 174 public java.util.List<UserTracker> findByUserId(long userId, int start, 175 int end); 176 177 /** 178 * Returns an ordered range of all the user trackers where userId = ?. 179 * 180 * <p> 181 * 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. 182 * </p> 183 * 184 * @param userId the user ID 185 * @param start the lower bound of the range of user trackers 186 * @param end the upper bound of the range of user trackers (not inclusive) 187 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 188 * @return the ordered range of matching user trackers 189 */ 190 public java.util.List<UserTracker> findByUserId(long userId, int start, 191 int end, 192 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator); 193 194 /** 195 * Returns the first user tracker in the ordered set where userId = ?. 196 * 197 * @param userId the user ID 198 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 199 * @return the first matching user tracker 200 * @throws NoSuchUserTrackerException if a matching user tracker could not be found 201 */ 202 public UserTracker findByUserId_First(long userId, 203 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator) 204 throws com.liferay.portal.NoSuchUserTrackerException; 205 206 /** 207 * Returns the first user tracker in the ordered set where userId = ?. 208 * 209 * @param userId the user ID 210 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 211 * @return the first matching user tracker, or <code>null</code> if a matching user tracker could not be found 212 */ 213 public UserTracker fetchByUserId_First(long userId, 214 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator); 215 216 /** 217 * Returns the last user tracker in the ordered set where userId = ?. 218 * 219 * @param userId the user ID 220 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 221 * @return the last matching user tracker 222 * @throws NoSuchUserTrackerException if a matching user tracker could not be found 223 */ 224 public UserTracker findByUserId_Last(long userId, 225 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator) 226 throws com.liferay.portal.NoSuchUserTrackerException; 227 228 /** 229 * Returns the last user tracker in the ordered set where userId = ?. 230 * 231 * @param userId the user ID 232 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 233 * @return the last matching user tracker, or <code>null</code> if a matching user tracker could not be found 234 */ 235 public UserTracker fetchByUserId_Last(long userId, 236 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator); 237 238 /** 239 * Returns the user trackers before and after the current user tracker in the ordered set where userId = ?. 240 * 241 * @param userTrackerId the primary key of the current user tracker 242 * @param userId the user ID 243 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 244 * @return the previous, current, and next user tracker 245 * @throws NoSuchUserTrackerException if a user tracker with the primary key could not be found 246 */ 247 public UserTracker[] findByUserId_PrevAndNext(long userTrackerId, 248 long userId, 249 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator) 250 throws com.liferay.portal.NoSuchUserTrackerException; 251 252 /** 253 * Removes all the user trackers where userId = ? from the database. 254 * 255 * @param userId the user ID 256 */ 257 public void removeByUserId(long userId); 258 259 /** 260 * Returns the number of user trackers where userId = ?. 261 * 262 * @param userId the user ID 263 * @return the number of matching user trackers 264 */ 265 public int countByUserId(long userId); 266 267 /** 268 * Returns all the user trackers where sessionId = ?. 269 * 270 * @param sessionId the session ID 271 * @return the matching user trackers 272 */ 273 public java.util.List<UserTracker> findBySessionId( 274 java.lang.String sessionId); 275 276 /** 277 * Returns a range of all the user trackers where sessionId = ?. 278 * 279 * <p> 280 * 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. 281 * </p> 282 * 283 * @param sessionId the session ID 284 * @param start the lower bound of the range of user trackers 285 * @param end the upper bound of the range of user trackers (not inclusive) 286 * @return the range of matching user trackers 287 */ 288 public java.util.List<UserTracker> findBySessionId( 289 java.lang.String sessionId, int start, int end); 290 291 /** 292 * Returns an ordered range of all the user trackers where sessionId = ?. 293 * 294 * <p> 295 * 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. 296 * </p> 297 * 298 * @param sessionId the session ID 299 * @param start the lower bound of the range of user trackers 300 * @param end the upper bound of the range of user trackers (not inclusive) 301 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 302 * @return the ordered range of matching user trackers 303 */ 304 public java.util.List<UserTracker> findBySessionId( 305 java.lang.String sessionId, int start, int end, 306 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator); 307 308 /** 309 * Returns the first user tracker in the ordered set where sessionId = ?. 310 * 311 * @param sessionId the session ID 312 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 313 * @return the first matching user tracker 314 * @throws NoSuchUserTrackerException if a matching user tracker could not be found 315 */ 316 public UserTracker findBySessionId_First(java.lang.String sessionId, 317 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator) 318 throws com.liferay.portal.NoSuchUserTrackerException; 319 320 /** 321 * Returns the first user tracker in the ordered set where sessionId = ?. 322 * 323 * @param sessionId the session ID 324 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 325 * @return the first matching user tracker, or <code>null</code> if a matching user tracker could not be found 326 */ 327 public UserTracker fetchBySessionId_First(java.lang.String sessionId, 328 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator); 329 330 /** 331 * Returns the last user tracker in the ordered set where sessionId = ?. 332 * 333 * @param sessionId the session ID 334 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 335 * @return the last matching user tracker 336 * @throws NoSuchUserTrackerException if a matching user tracker could not be found 337 */ 338 public UserTracker findBySessionId_Last(java.lang.String sessionId, 339 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator) 340 throws com.liferay.portal.NoSuchUserTrackerException; 341 342 /** 343 * Returns the last user tracker in the ordered set where sessionId = ?. 344 * 345 * @param sessionId the session ID 346 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 347 * @return the last matching user tracker, or <code>null</code> if a matching user tracker could not be found 348 */ 349 public UserTracker fetchBySessionId_Last(java.lang.String sessionId, 350 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator); 351 352 /** 353 * Returns the user trackers before and after the current user tracker in the ordered set where sessionId = ?. 354 * 355 * @param userTrackerId the primary key of the current user tracker 356 * @param sessionId the session ID 357 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 358 * @return the previous, current, and next user tracker 359 * @throws NoSuchUserTrackerException if a user tracker with the primary key could not be found 360 */ 361 public UserTracker[] findBySessionId_PrevAndNext(long userTrackerId, 362 java.lang.String sessionId, 363 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator) 364 throws com.liferay.portal.NoSuchUserTrackerException; 365 366 /** 367 * Removes all the user trackers where sessionId = ? from the database. 368 * 369 * @param sessionId the session ID 370 */ 371 public void removeBySessionId(java.lang.String sessionId); 372 373 /** 374 * Returns the number of user trackers where sessionId = ?. 375 * 376 * @param sessionId the session ID 377 * @return the number of matching user trackers 378 */ 379 public int countBySessionId(java.lang.String sessionId); 380 381 /** 382 * Caches the user tracker in the entity cache if it is enabled. 383 * 384 * @param userTracker the user tracker 385 */ 386 public void cacheResult(UserTracker userTracker); 387 388 /** 389 * Caches the user trackers in the entity cache if it is enabled. 390 * 391 * @param userTrackers the user trackers 392 */ 393 public void cacheResult(java.util.List<UserTracker> userTrackers); 394 395 /** 396 * Creates a new user tracker with the primary key. Does not add the user tracker to the database. 397 * 398 * @param userTrackerId the primary key for the new user tracker 399 * @return the new user tracker 400 */ 401 public UserTracker create(long userTrackerId); 402 403 /** 404 * Removes the user tracker with the primary key from the database. Also notifies the appropriate model listeners. 405 * 406 * @param userTrackerId the primary key of the user tracker 407 * @return the user tracker that was removed 408 * @throws NoSuchUserTrackerException if a user tracker with the primary key could not be found 409 */ 410 public UserTracker remove(long userTrackerId) 411 throws com.liferay.portal.NoSuchUserTrackerException; 412 413 public UserTracker updateImpl(UserTracker userTracker); 414 415 /** 416 * Returns the user tracker with the primary key or throws a {@link NoSuchUserTrackerException} if it could not be found. 417 * 418 * @param userTrackerId the primary key of the user tracker 419 * @return the user tracker 420 * @throws NoSuchUserTrackerException if a user tracker with the primary key could not be found 421 */ 422 public UserTracker findByPrimaryKey(long userTrackerId) 423 throws com.liferay.portal.NoSuchUserTrackerException; 424 425 /** 426 * Returns the user tracker with the primary key or returns <code>null</code> if it could not be found. 427 * 428 * @param userTrackerId the primary key of the user tracker 429 * @return the user tracker, or <code>null</code> if a user tracker with the primary key could not be found 430 */ 431 public UserTracker fetchByPrimaryKey(long userTrackerId); 432 433 @Override 434 public java.util.Map<java.io.Serializable, UserTracker> fetchByPrimaryKeys( 435 java.util.Set<java.io.Serializable> primaryKeys); 436 437 /** 438 * Returns all the user trackers. 439 * 440 * @return the user trackers 441 */ 442 public java.util.List<UserTracker> findAll(); 443 444 /** 445 * Returns a range of all the user trackers. 446 * 447 * <p> 448 * 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. 449 * </p> 450 * 451 * @param start the lower bound of the range of user trackers 452 * @param end the upper bound of the range of user trackers (not inclusive) 453 * @return the range of user trackers 454 */ 455 public java.util.List<UserTracker> findAll(int start, int end); 456 457 /** 458 * Returns an ordered range of all the user trackers. 459 * 460 * <p> 461 * 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. 462 * </p> 463 * 464 * @param start the lower bound of the range of user trackers 465 * @param end the upper bound of the range of user trackers (not inclusive) 466 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 467 * @return the ordered range of user trackers 468 */ 469 public java.util.List<UserTracker> findAll(int start, int end, 470 com.liferay.portal.kernel.util.OrderByComparator<UserTracker> orderByComparator); 471 472 /** 473 * Removes all the user trackers from the database. 474 */ 475 public void removeAll(); 476 477 /** 478 * Returns the number of user trackers. 479 * 480 * @return the number of user trackers 481 */ 482 public int countAll(); 483 }