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.kernel.bean.PortalBeanLocatorUtil; 020 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 021 import com.liferay.portal.kernel.util.OrderByComparator; 022 import com.liferay.portal.kernel.util.ReferenceRegistry; 023 import com.liferay.portal.model.UserTracker; 024 import com.liferay.portal.service.ServiceContext; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the user tracker service. This utility wraps {@link com.liferay.portal.service.persistence.impl.UserTrackerPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 030 * 031 * <p> 032 * Caching information and settings can be found in <code>portal.properties</code> 033 * </p> 034 * 035 * @author Brian Wing Shun Chan 036 * @see UserTrackerPersistence 037 * @see com.liferay.portal.service.persistence.impl.UserTrackerPersistenceImpl 038 * @generated 039 */ 040 @ProviderType 041 public class UserTrackerUtil { 042 /* 043 * NOTE FOR DEVELOPERS: 044 * 045 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 046 */ 047 048 /** 049 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 050 */ 051 public static void clearCache() { 052 getPersistence().clearCache(); 053 } 054 055 /** 056 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 057 */ 058 public static void clearCache(UserTracker userTracker) { 059 getPersistence().clearCache(userTracker); 060 } 061 062 /** 063 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 064 */ 065 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 066 return getPersistence().countWithDynamicQuery(dynamicQuery); 067 } 068 069 /** 070 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 071 */ 072 public static List<UserTracker> findWithDynamicQuery( 073 DynamicQuery dynamicQuery) { 074 return getPersistence().findWithDynamicQuery(dynamicQuery); 075 } 076 077 /** 078 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 079 */ 080 public static List<UserTracker> findWithDynamicQuery( 081 DynamicQuery dynamicQuery, int start, int end) { 082 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 083 } 084 085 /** 086 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 087 */ 088 public static List<UserTracker> findWithDynamicQuery( 089 DynamicQuery dynamicQuery, int start, int end, 090 OrderByComparator<UserTracker> orderByComparator) { 091 return getPersistence() 092 .findWithDynamicQuery(dynamicQuery, start, end, 093 orderByComparator); 094 } 095 096 /** 097 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 098 */ 099 public static UserTracker update(UserTracker userTracker) { 100 return getPersistence().update(userTracker); 101 } 102 103 /** 104 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 105 */ 106 public static UserTracker update(UserTracker userTracker, 107 ServiceContext serviceContext) { 108 return getPersistence().update(userTracker, serviceContext); 109 } 110 111 /** 112 * Returns all the user trackers where companyId = ?. 113 * 114 * @param companyId the company ID 115 * @return the matching user trackers 116 */ 117 public static List<UserTracker> findByCompanyId(long companyId) { 118 return getPersistence().findByCompanyId(companyId); 119 } 120 121 /** 122 * Returns a range of all the user trackers where companyId = ?. 123 * 124 * <p> 125 * 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. 126 * </p> 127 * 128 * @param companyId the company ID 129 * @param start the lower bound of the range of user trackers 130 * @param end the upper bound of the range of user trackers (not inclusive) 131 * @return the range of matching user trackers 132 */ 133 public static List<UserTracker> findByCompanyId(long companyId, int start, 134 int end) { 135 return getPersistence().findByCompanyId(companyId, start, end); 136 } 137 138 /** 139 * Returns an ordered range of all the user trackers where companyId = ?. 140 * 141 * <p> 142 * 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. 143 * </p> 144 * 145 * @param companyId the company ID 146 * @param start the lower bound of the range of user trackers 147 * @param end the upper bound of the range of user trackers (not inclusive) 148 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 149 * @return the ordered range of matching user trackers 150 */ 151 public static List<UserTracker> findByCompanyId(long companyId, int start, 152 int end, OrderByComparator<UserTracker> orderByComparator) { 153 return getPersistence() 154 .findByCompanyId(companyId, start, end, orderByComparator); 155 } 156 157 /** 158 * Returns an ordered range of all the user trackers where companyId = ?. 159 * 160 * <p> 161 * 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. 162 * </p> 163 * 164 * @param companyId the company ID 165 * @param start the lower bound of the range of user trackers 166 * @param end the upper bound of the range of user trackers (not inclusive) 167 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 168 * @param retrieveFromCache whether to retrieve from the finder cache 169 * @return the ordered range of matching user trackers 170 */ 171 public static List<UserTracker> findByCompanyId(long companyId, int start, 172 int end, OrderByComparator<UserTracker> orderByComparator, 173 boolean retrieveFromCache) { 174 return getPersistence() 175 .findByCompanyId(companyId, start, end, orderByComparator, 176 retrieveFromCache); 177 } 178 179 /** 180 * Returns the first user tracker in the ordered set where companyId = ?. 181 * 182 * @param companyId the company ID 183 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 184 * @return the first matching user tracker 185 * @throws NoSuchUserTrackerException if a matching user tracker could not be found 186 */ 187 public static UserTracker findByCompanyId_First(long companyId, 188 OrderByComparator<UserTracker> orderByComparator) 189 throws com.liferay.portal.exception.NoSuchUserTrackerException { 190 return getPersistence() 191 .findByCompanyId_First(companyId, orderByComparator); 192 } 193 194 /** 195 * Returns the first user tracker in the ordered set where companyId = ?. 196 * 197 * @param companyId the company ID 198 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 199 * @return the first matching user tracker, or <code>null</code> if a matching user tracker could not be found 200 */ 201 public static UserTracker fetchByCompanyId_First(long companyId, 202 OrderByComparator<UserTracker> orderByComparator) { 203 return getPersistence() 204 .fetchByCompanyId_First(companyId, orderByComparator); 205 } 206 207 /** 208 * Returns the last user tracker in the ordered set where companyId = ?. 209 * 210 * @param companyId the company ID 211 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 212 * @return the last matching user tracker 213 * @throws NoSuchUserTrackerException if a matching user tracker could not be found 214 */ 215 public static UserTracker findByCompanyId_Last(long companyId, 216 OrderByComparator<UserTracker> orderByComparator) 217 throws com.liferay.portal.exception.NoSuchUserTrackerException { 218 return getPersistence() 219 .findByCompanyId_Last(companyId, orderByComparator); 220 } 221 222 /** 223 * Returns the last user tracker in the ordered set where companyId = ?. 224 * 225 * @param companyId the company ID 226 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 227 * @return the last matching user tracker, or <code>null</code> if a matching user tracker could not be found 228 */ 229 public static UserTracker fetchByCompanyId_Last(long companyId, 230 OrderByComparator<UserTracker> orderByComparator) { 231 return getPersistence() 232 .fetchByCompanyId_Last(companyId, orderByComparator); 233 } 234 235 /** 236 * Returns the user trackers before and after the current user tracker in the ordered set where companyId = ?. 237 * 238 * @param userTrackerId the primary key of the current user tracker 239 * @param companyId the company ID 240 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 241 * @return the previous, current, and next user tracker 242 * @throws NoSuchUserTrackerException if a user tracker with the primary key could not be found 243 */ 244 public static UserTracker[] findByCompanyId_PrevAndNext( 245 long userTrackerId, long companyId, 246 OrderByComparator<UserTracker> orderByComparator) 247 throws com.liferay.portal.exception.NoSuchUserTrackerException { 248 return getPersistence() 249 .findByCompanyId_PrevAndNext(userTrackerId, companyId, 250 orderByComparator); 251 } 252 253 /** 254 * Removes all the user trackers where companyId = ? from the database. 255 * 256 * @param companyId the company ID 257 */ 258 public static void removeByCompanyId(long companyId) { 259 getPersistence().removeByCompanyId(companyId); 260 } 261 262 /** 263 * Returns the number of user trackers where companyId = ?. 264 * 265 * @param companyId the company ID 266 * @return the number of matching user trackers 267 */ 268 public static int countByCompanyId(long companyId) { 269 return getPersistence().countByCompanyId(companyId); 270 } 271 272 /** 273 * Returns all the user trackers where userId = ?. 274 * 275 * @param userId the user ID 276 * @return the matching user trackers 277 */ 278 public static List<UserTracker> findByUserId(long userId) { 279 return getPersistence().findByUserId(userId); 280 } 281 282 /** 283 * Returns a range of all the user trackers where userId = ?. 284 * 285 * <p> 286 * 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. 287 * </p> 288 * 289 * @param userId the user ID 290 * @param start the lower bound of the range of user trackers 291 * @param end the upper bound of the range of user trackers (not inclusive) 292 * @return the range of matching user trackers 293 */ 294 public static List<UserTracker> findByUserId(long userId, int start, int end) { 295 return getPersistence().findByUserId(userId, start, end); 296 } 297 298 /** 299 * Returns an ordered range of all the user trackers where userId = ?. 300 * 301 * <p> 302 * 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. 303 * </p> 304 * 305 * @param userId the user ID 306 * @param start the lower bound of the range of user trackers 307 * @param end the upper bound of the range of user trackers (not inclusive) 308 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 309 * @return the ordered range of matching user trackers 310 */ 311 public static List<UserTracker> findByUserId(long userId, int start, 312 int end, OrderByComparator<UserTracker> orderByComparator) { 313 return getPersistence() 314 .findByUserId(userId, start, end, orderByComparator); 315 } 316 317 /** 318 * Returns an ordered range of all the user trackers where userId = ?. 319 * 320 * <p> 321 * 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. 322 * </p> 323 * 324 * @param userId the user ID 325 * @param start the lower bound of the range of user trackers 326 * @param end the upper bound of the range of user trackers (not inclusive) 327 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 328 * @param retrieveFromCache whether to retrieve from the finder cache 329 * @return the ordered range of matching user trackers 330 */ 331 public static List<UserTracker> findByUserId(long userId, int start, 332 int end, OrderByComparator<UserTracker> orderByComparator, 333 boolean retrieveFromCache) { 334 return getPersistence() 335 .findByUserId(userId, start, end, orderByComparator, 336 retrieveFromCache); 337 } 338 339 /** 340 * Returns the first user tracker in the ordered set where userId = ?. 341 * 342 * @param userId the user ID 343 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 344 * @return the first matching user tracker 345 * @throws NoSuchUserTrackerException if a matching user tracker could not be found 346 */ 347 public static UserTracker findByUserId_First(long userId, 348 OrderByComparator<UserTracker> orderByComparator) 349 throws com.liferay.portal.exception.NoSuchUserTrackerException { 350 return getPersistence().findByUserId_First(userId, orderByComparator); 351 } 352 353 /** 354 * Returns the first user tracker in the ordered set where userId = ?. 355 * 356 * @param userId the user ID 357 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 358 * @return the first matching user tracker, or <code>null</code> if a matching user tracker could not be found 359 */ 360 public static UserTracker fetchByUserId_First(long userId, 361 OrderByComparator<UserTracker> orderByComparator) { 362 return getPersistence().fetchByUserId_First(userId, orderByComparator); 363 } 364 365 /** 366 * Returns the last user tracker in the ordered set where userId = ?. 367 * 368 * @param userId the user ID 369 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 370 * @return the last matching user tracker 371 * @throws NoSuchUserTrackerException if a matching user tracker could not be found 372 */ 373 public static UserTracker findByUserId_Last(long userId, 374 OrderByComparator<UserTracker> orderByComparator) 375 throws com.liferay.portal.exception.NoSuchUserTrackerException { 376 return getPersistence().findByUserId_Last(userId, orderByComparator); 377 } 378 379 /** 380 * Returns the last user tracker in the ordered set where userId = ?. 381 * 382 * @param userId the user ID 383 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 384 * @return the last matching user tracker, or <code>null</code> if a matching user tracker could not be found 385 */ 386 public static UserTracker fetchByUserId_Last(long userId, 387 OrderByComparator<UserTracker> orderByComparator) { 388 return getPersistence().fetchByUserId_Last(userId, orderByComparator); 389 } 390 391 /** 392 * Returns the user trackers before and after the current user tracker in the ordered set where userId = ?. 393 * 394 * @param userTrackerId the primary key of the current user tracker 395 * @param userId the user ID 396 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 397 * @return the previous, current, and next user tracker 398 * @throws NoSuchUserTrackerException if a user tracker with the primary key could not be found 399 */ 400 public static UserTracker[] findByUserId_PrevAndNext(long userTrackerId, 401 long userId, OrderByComparator<UserTracker> orderByComparator) 402 throws com.liferay.portal.exception.NoSuchUserTrackerException { 403 return getPersistence() 404 .findByUserId_PrevAndNext(userTrackerId, userId, 405 orderByComparator); 406 } 407 408 /** 409 * Removes all the user trackers where userId = ? from the database. 410 * 411 * @param userId the user ID 412 */ 413 public static void removeByUserId(long userId) { 414 getPersistence().removeByUserId(userId); 415 } 416 417 /** 418 * Returns the number of user trackers where userId = ?. 419 * 420 * @param userId the user ID 421 * @return the number of matching user trackers 422 */ 423 public static int countByUserId(long userId) { 424 return getPersistence().countByUserId(userId); 425 } 426 427 /** 428 * Returns all the user trackers where sessionId = ?. 429 * 430 * @param sessionId the session ID 431 * @return the matching user trackers 432 */ 433 public static List<UserTracker> findBySessionId(java.lang.String sessionId) { 434 return getPersistence().findBySessionId(sessionId); 435 } 436 437 /** 438 * Returns a range of all the user trackers where sessionId = ?. 439 * 440 * <p> 441 * 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. 442 * </p> 443 * 444 * @param sessionId the session ID 445 * @param start the lower bound of the range of user trackers 446 * @param end the upper bound of the range of user trackers (not inclusive) 447 * @return the range of matching user trackers 448 */ 449 public static List<UserTracker> findBySessionId( 450 java.lang.String sessionId, int start, int end) { 451 return getPersistence().findBySessionId(sessionId, start, end); 452 } 453 454 /** 455 * Returns an ordered range of all the user trackers where sessionId = ?. 456 * 457 * <p> 458 * 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. 459 * </p> 460 * 461 * @param sessionId the session ID 462 * @param start the lower bound of the range of user trackers 463 * @param end the upper bound of the range of user trackers (not inclusive) 464 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 465 * @return the ordered range of matching user trackers 466 */ 467 public static List<UserTracker> findBySessionId( 468 java.lang.String sessionId, int start, int end, 469 OrderByComparator<UserTracker> orderByComparator) { 470 return getPersistence() 471 .findBySessionId(sessionId, start, end, orderByComparator); 472 } 473 474 /** 475 * Returns an ordered range of all the user trackers where sessionId = ?. 476 * 477 * <p> 478 * 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. 479 * </p> 480 * 481 * @param sessionId the session ID 482 * @param start the lower bound of the range of user trackers 483 * @param end the upper bound of the range of user trackers (not inclusive) 484 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 485 * @param retrieveFromCache whether to retrieve from the finder cache 486 * @return the ordered range of matching user trackers 487 */ 488 public static List<UserTracker> findBySessionId( 489 java.lang.String sessionId, int start, int end, 490 OrderByComparator<UserTracker> orderByComparator, 491 boolean retrieveFromCache) { 492 return getPersistence() 493 .findBySessionId(sessionId, start, end, orderByComparator, 494 retrieveFromCache); 495 } 496 497 /** 498 * Returns the first user tracker in the ordered set where sessionId = ?. 499 * 500 * @param sessionId the session ID 501 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 502 * @return the first matching user tracker 503 * @throws NoSuchUserTrackerException if a matching user tracker could not be found 504 */ 505 public static UserTracker findBySessionId_First( 506 java.lang.String sessionId, 507 OrderByComparator<UserTracker> orderByComparator) 508 throws com.liferay.portal.exception.NoSuchUserTrackerException { 509 return getPersistence() 510 .findBySessionId_First(sessionId, orderByComparator); 511 } 512 513 /** 514 * Returns the first user tracker in the ordered set where sessionId = ?. 515 * 516 * @param sessionId the session ID 517 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 518 * @return the first matching user tracker, or <code>null</code> if a matching user tracker could not be found 519 */ 520 public static UserTracker fetchBySessionId_First( 521 java.lang.String sessionId, 522 OrderByComparator<UserTracker> orderByComparator) { 523 return getPersistence() 524 .fetchBySessionId_First(sessionId, orderByComparator); 525 } 526 527 /** 528 * Returns the last user tracker in the ordered set where sessionId = ?. 529 * 530 * @param sessionId the session ID 531 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 532 * @return the last matching user tracker 533 * @throws NoSuchUserTrackerException if a matching user tracker could not be found 534 */ 535 public static UserTracker findBySessionId_Last(java.lang.String sessionId, 536 OrderByComparator<UserTracker> orderByComparator) 537 throws com.liferay.portal.exception.NoSuchUserTrackerException { 538 return getPersistence() 539 .findBySessionId_Last(sessionId, orderByComparator); 540 } 541 542 /** 543 * Returns the last user tracker in the ordered set where sessionId = ?. 544 * 545 * @param sessionId the session ID 546 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 547 * @return the last matching user tracker, or <code>null</code> if a matching user tracker could not be found 548 */ 549 public static UserTracker fetchBySessionId_Last( 550 java.lang.String sessionId, 551 OrderByComparator<UserTracker> orderByComparator) { 552 return getPersistence() 553 .fetchBySessionId_Last(sessionId, orderByComparator); 554 } 555 556 /** 557 * Returns the user trackers before and after the current user tracker in the ordered set where sessionId = ?. 558 * 559 * @param userTrackerId the primary key of the current user tracker 560 * @param sessionId the session ID 561 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 562 * @return the previous, current, and next user tracker 563 * @throws NoSuchUserTrackerException if a user tracker with the primary key could not be found 564 */ 565 public static UserTracker[] findBySessionId_PrevAndNext( 566 long userTrackerId, java.lang.String sessionId, 567 OrderByComparator<UserTracker> orderByComparator) 568 throws com.liferay.portal.exception.NoSuchUserTrackerException { 569 return getPersistence() 570 .findBySessionId_PrevAndNext(userTrackerId, sessionId, 571 orderByComparator); 572 } 573 574 /** 575 * Removes all the user trackers where sessionId = ? from the database. 576 * 577 * @param sessionId the session ID 578 */ 579 public static void removeBySessionId(java.lang.String sessionId) { 580 getPersistence().removeBySessionId(sessionId); 581 } 582 583 /** 584 * Returns the number of user trackers where sessionId = ?. 585 * 586 * @param sessionId the session ID 587 * @return the number of matching user trackers 588 */ 589 public static int countBySessionId(java.lang.String sessionId) { 590 return getPersistence().countBySessionId(sessionId); 591 } 592 593 /** 594 * Caches the user tracker in the entity cache if it is enabled. 595 * 596 * @param userTracker the user tracker 597 */ 598 public static void cacheResult(UserTracker userTracker) { 599 getPersistence().cacheResult(userTracker); 600 } 601 602 /** 603 * Caches the user trackers in the entity cache if it is enabled. 604 * 605 * @param userTrackers the user trackers 606 */ 607 public static void cacheResult(List<UserTracker> userTrackers) { 608 getPersistence().cacheResult(userTrackers); 609 } 610 611 /** 612 * Creates a new user tracker with the primary key. Does not add the user tracker to the database. 613 * 614 * @param userTrackerId the primary key for the new user tracker 615 * @return the new user tracker 616 */ 617 public static UserTracker create(long userTrackerId) { 618 return getPersistence().create(userTrackerId); 619 } 620 621 /** 622 * Removes the user tracker with the primary key from the database. Also notifies the appropriate model listeners. 623 * 624 * @param userTrackerId the primary key of the user tracker 625 * @return the user tracker that was removed 626 * @throws NoSuchUserTrackerException if a user tracker with the primary key could not be found 627 */ 628 public static UserTracker remove(long userTrackerId) 629 throws com.liferay.portal.exception.NoSuchUserTrackerException { 630 return getPersistence().remove(userTrackerId); 631 } 632 633 public static UserTracker updateImpl(UserTracker userTracker) { 634 return getPersistence().updateImpl(userTracker); 635 } 636 637 /** 638 * Returns the user tracker with the primary key or throws a {@link NoSuchUserTrackerException} if it could not be found. 639 * 640 * @param userTrackerId the primary key of the user tracker 641 * @return the user tracker 642 * @throws NoSuchUserTrackerException if a user tracker with the primary key could not be found 643 */ 644 public static UserTracker findByPrimaryKey(long userTrackerId) 645 throws com.liferay.portal.exception.NoSuchUserTrackerException { 646 return getPersistence().findByPrimaryKey(userTrackerId); 647 } 648 649 /** 650 * Returns the user tracker with the primary key or returns <code>null</code> if it could not be found. 651 * 652 * @param userTrackerId the primary key of the user tracker 653 * @return the user tracker, or <code>null</code> if a user tracker with the primary key could not be found 654 */ 655 public static UserTracker fetchByPrimaryKey(long userTrackerId) { 656 return getPersistence().fetchByPrimaryKey(userTrackerId); 657 } 658 659 public static java.util.Map<java.io.Serializable, UserTracker> fetchByPrimaryKeys( 660 java.util.Set<java.io.Serializable> primaryKeys) { 661 return getPersistence().fetchByPrimaryKeys(primaryKeys); 662 } 663 664 /** 665 * Returns all the user trackers. 666 * 667 * @return the user trackers 668 */ 669 public static List<UserTracker> findAll() { 670 return getPersistence().findAll(); 671 } 672 673 /** 674 * Returns a range of all the user trackers. 675 * 676 * <p> 677 * 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. 678 * </p> 679 * 680 * @param start the lower bound of the range of user trackers 681 * @param end the upper bound of the range of user trackers (not inclusive) 682 * @return the range of user trackers 683 */ 684 public static List<UserTracker> findAll(int start, int end) { 685 return getPersistence().findAll(start, end); 686 } 687 688 /** 689 * Returns an ordered range of all the user trackers. 690 * 691 * <p> 692 * 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. 693 * </p> 694 * 695 * @param start the lower bound of the range of user trackers 696 * @param end the upper bound of the range of user trackers (not inclusive) 697 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 698 * @return the ordered range of user trackers 699 */ 700 public static List<UserTracker> findAll(int start, int end, 701 OrderByComparator<UserTracker> orderByComparator) { 702 return getPersistence().findAll(start, end, orderByComparator); 703 } 704 705 /** 706 * Returns an ordered range of all the user trackers. 707 * 708 * <p> 709 * 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. 710 * </p> 711 * 712 * @param start the lower bound of the range of user trackers 713 * @param end the upper bound of the range of user trackers (not inclusive) 714 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 715 * @param retrieveFromCache whether to retrieve from the finder cache 716 * @return the ordered range of user trackers 717 */ 718 public static List<UserTracker> findAll(int start, int end, 719 OrderByComparator<UserTracker> orderByComparator, 720 boolean retrieveFromCache) { 721 return getPersistence() 722 .findAll(start, end, orderByComparator, retrieveFromCache); 723 } 724 725 /** 726 * Removes all the user trackers from the database. 727 */ 728 public static void removeAll() { 729 getPersistence().removeAll(); 730 } 731 732 /** 733 * Returns the number of user trackers. 734 * 735 * @return the number of user trackers 736 */ 737 public static int countAll() { 738 return getPersistence().countAll(); 739 } 740 741 public static UserTrackerPersistence getPersistence() { 742 if (_persistence == null) { 743 _persistence = (UserTrackerPersistence)PortalBeanLocatorUtil.locate(UserTrackerPersistence.class.getName()); 744 745 ReferenceRegistry.registerReference(UserTrackerUtil.class, 746 "_persistence"); 747 } 748 749 return _persistence; 750 } 751 752 private static UserTrackerPersistence _persistence; 753 }