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.UserTrackerPath; 024 import com.liferay.portal.service.ServiceContext; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the user tracker path service. This utility wraps {@link com.liferay.portal.service.persistence.impl.UserTrackerPathPersistenceImpl} 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 UserTrackerPathPersistence 037 * @see com.liferay.portal.service.persistence.impl.UserTrackerPathPersistenceImpl 038 * @generated 039 */ 040 @ProviderType 041 public class UserTrackerPathUtil { 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(UserTrackerPath userTrackerPath) { 059 getPersistence().clearCache(userTrackerPath); 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<UserTrackerPath> 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<UserTrackerPath> 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<UserTrackerPath> findWithDynamicQuery( 089 DynamicQuery dynamicQuery, int start, int end, 090 OrderByComparator<UserTrackerPath> 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 UserTrackerPath update(UserTrackerPath userTrackerPath) { 100 return getPersistence().update(userTrackerPath); 101 } 102 103 /** 104 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 105 */ 106 public static UserTrackerPath update(UserTrackerPath userTrackerPath, 107 ServiceContext serviceContext) { 108 return getPersistence().update(userTrackerPath, serviceContext); 109 } 110 111 /** 112 * Returns all the user tracker paths where userTrackerId = ?. 113 * 114 * @param userTrackerId the user tracker ID 115 * @return the matching user tracker paths 116 */ 117 public static List<UserTrackerPath> findByUserTrackerId(long userTrackerId) { 118 return getPersistence().findByUserTrackerId(userTrackerId); 119 } 120 121 /** 122 * Returns a range of all the user tracker paths where userTrackerId = ?. 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 UserTrackerPathModelImpl}. 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 userTrackerId the user tracker ID 129 * @param start the lower bound of the range of user tracker paths 130 * @param end the upper bound of the range of user tracker paths (not inclusive) 131 * @return the range of matching user tracker paths 132 */ 133 public static List<UserTrackerPath> findByUserTrackerId( 134 long userTrackerId, int start, int end) { 135 return getPersistence().findByUserTrackerId(userTrackerId, start, end); 136 } 137 138 /** 139 * Returns an ordered range of all the user tracker paths where userTrackerId = ?. 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 UserTrackerPathModelImpl}. 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 userTrackerId the user tracker ID 146 * @param start the lower bound of the range of user tracker paths 147 * @param end the upper bound of the range of user tracker paths (not inclusive) 148 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 149 * @return the ordered range of matching user tracker paths 150 */ 151 public static List<UserTrackerPath> findByUserTrackerId( 152 long userTrackerId, int start, int end, 153 OrderByComparator<UserTrackerPath> orderByComparator) { 154 return getPersistence() 155 .findByUserTrackerId(userTrackerId, start, end, 156 orderByComparator); 157 } 158 159 /** 160 * Returns an ordered range of all the user tracker paths where userTrackerId = ?. 161 * 162 * <p> 163 * 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 UserTrackerPathModelImpl}. 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. 164 * </p> 165 * 166 * @param userTrackerId the user tracker ID 167 * @param start the lower bound of the range of user tracker paths 168 * @param end the upper bound of the range of user tracker paths (not inclusive) 169 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 170 * @param retrieveFromCache whether to retrieve from the finder cache 171 * @return the ordered range of matching user tracker paths 172 */ 173 public static List<UserTrackerPath> findByUserTrackerId( 174 long userTrackerId, int start, int end, 175 OrderByComparator<UserTrackerPath> orderByComparator, 176 boolean retrieveFromCache) { 177 return getPersistence() 178 .findByUserTrackerId(userTrackerId, start, end, 179 orderByComparator, retrieveFromCache); 180 } 181 182 /** 183 * Returns the first user tracker path in the ordered set where userTrackerId = ?. 184 * 185 * @param userTrackerId the user tracker ID 186 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 187 * @return the first matching user tracker path 188 * @throws NoSuchUserTrackerPathException if a matching user tracker path could not be found 189 */ 190 public static UserTrackerPath findByUserTrackerId_First( 191 long userTrackerId, OrderByComparator<UserTrackerPath> orderByComparator) 192 throws com.liferay.portal.exception.NoSuchUserTrackerPathException { 193 return getPersistence() 194 .findByUserTrackerId_First(userTrackerId, orderByComparator); 195 } 196 197 /** 198 * Returns the first user tracker path in the ordered set where userTrackerId = ?. 199 * 200 * @param userTrackerId the user tracker ID 201 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 202 * @return the first matching user tracker path, or <code>null</code> if a matching user tracker path could not be found 203 */ 204 public static UserTrackerPath fetchByUserTrackerId_First( 205 long userTrackerId, OrderByComparator<UserTrackerPath> orderByComparator) { 206 return getPersistence() 207 .fetchByUserTrackerId_First(userTrackerId, orderByComparator); 208 } 209 210 /** 211 * Returns the last user tracker path in the ordered set where userTrackerId = ?. 212 * 213 * @param userTrackerId the user tracker ID 214 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 215 * @return the last matching user tracker path 216 * @throws NoSuchUserTrackerPathException if a matching user tracker path could not be found 217 */ 218 public static UserTrackerPath findByUserTrackerId_Last(long userTrackerId, 219 OrderByComparator<UserTrackerPath> orderByComparator) 220 throws com.liferay.portal.exception.NoSuchUserTrackerPathException { 221 return getPersistence() 222 .findByUserTrackerId_Last(userTrackerId, orderByComparator); 223 } 224 225 /** 226 * Returns the last user tracker path in the ordered set where userTrackerId = ?. 227 * 228 * @param userTrackerId the user tracker ID 229 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 230 * @return the last matching user tracker path, or <code>null</code> if a matching user tracker path could not be found 231 */ 232 public static UserTrackerPath fetchByUserTrackerId_Last( 233 long userTrackerId, OrderByComparator<UserTrackerPath> orderByComparator) { 234 return getPersistence() 235 .fetchByUserTrackerId_Last(userTrackerId, orderByComparator); 236 } 237 238 /** 239 * Returns the user tracker paths before and after the current user tracker path in the ordered set where userTrackerId = ?. 240 * 241 * @param userTrackerPathId the primary key of the current user tracker path 242 * @param userTrackerId the user tracker ID 243 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 244 * @return the previous, current, and next user tracker path 245 * @throws NoSuchUserTrackerPathException if a user tracker path with the primary key could not be found 246 */ 247 public static UserTrackerPath[] findByUserTrackerId_PrevAndNext( 248 long userTrackerPathId, long userTrackerId, 249 OrderByComparator<UserTrackerPath> orderByComparator) 250 throws com.liferay.portal.exception.NoSuchUserTrackerPathException { 251 return getPersistence() 252 .findByUserTrackerId_PrevAndNext(userTrackerPathId, 253 userTrackerId, orderByComparator); 254 } 255 256 /** 257 * Removes all the user tracker paths where userTrackerId = ? from the database. 258 * 259 * @param userTrackerId the user tracker ID 260 */ 261 public static void removeByUserTrackerId(long userTrackerId) { 262 getPersistence().removeByUserTrackerId(userTrackerId); 263 } 264 265 /** 266 * Returns the number of user tracker paths where userTrackerId = ?. 267 * 268 * @param userTrackerId the user tracker ID 269 * @return the number of matching user tracker paths 270 */ 271 public static int countByUserTrackerId(long userTrackerId) { 272 return getPersistence().countByUserTrackerId(userTrackerId); 273 } 274 275 /** 276 * Caches the user tracker path in the entity cache if it is enabled. 277 * 278 * @param userTrackerPath the user tracker path 279 */ 280 public static void cacheResult(UserTrackerPath userTrackerPath) { 281 getPersistence().cacheResult(userTrackerPath); 282 } 283 284 /** 285 * Caches the user tracker paths in the entity cache if it is enabled. 286 * 287 * @param userTrackerPaths the user tracker paths 288 */ 289 public static void cacheResult(List<UserTrackerPath> userTrackerPaths) { 290 getPersistence().cacheResult(userTrackerPaths); 291 } 292 293 /** 294 * Creates a new user tracker path with the primary key. Does not add the user tracker path to the database. 295 * 296 * @param userTrackerPathId the primary key for the new user tracker path 297 * @return the new user tracker path 298 */ 299 public static UserTrackerPath create(long userTrackerPathId) { 300 return getPersistence().create(userTrackerPathId); 301 } 302 303 /** 304 * Removes the user tracker path with the primary key from the database. Also notifies the appropriate model listeners. 305 * 306 * @param userTrackerPathId the primary key of the user tracker path 307 * @return the user tracker path that was removed 308 * @throws NoSuchUserTrackerPathException if a user tracker path with the primary key could not be found 309 */ 310 public static UserTrackerPath remove(long userTrackerPathId) 311 throws com.liferay.portal.exception.NoSuchUserTrackerPathException { 312 return getPersistence().remove(userTrackerPathId); 313 } 314 315 public static UserTrackerPath updateImpl(UserTrackerPath userTrackerPath) { 316 return getPersistence().updateImpl(userTrackerPath); 317 } 318 319 /** 320 * Returns the user tracker path with the primary key or throws a {@link NoSuchUserTrackerPathException} if it could not be found. 321 * 322 * @param userTrackerPathId the primary key of the user tracker path 323 * @return the user tracker path 324 * @throws NoSuchUserTrackerPathException if a user tracker path with the primary key could not be found 325 */ 326 public static UserTrackerPath findByPrimaryKey(long userTrackerPathId) 327 throws com.liferay.portal.exception.NoSuchUserTrackerPathException { 328 return getPersistence().findByPrimaryKey(userTrackerPathId); 329 } 330 331 /** 332 * Returns the user tracker path with the primary key or returns <code>null</code> if it could not be found. 333 * 334 * @param userTrackerPathId the primary key of the user tracker path 335 * @return the user tracker path, or <code>null</code> if a user tracker path with the primary key could not be found 336 */ 337 public static UserTrackerPath fetchByPrimaryKey(long userTrackerPathId) { 338 return getPersistence().fetchByPrimaryKey(userTrackerPathId); 339 } 340 341 public static java.util.Map<java.io.Serializable, UserTrackerPath> fetchByPrimaryKeys( 342 java.util.Set<java.io.Serializable> primaryKeys) { 343 return getPersistence().fetchByPrimaryKeys(primaryKeys); 344 } 345 346 /** 347 * Returns all the user tracker paths. 348 * 349 * @return the user tracker paths 350 */ 351 public static List<UserTrackerPath> findAll() { 352 return getPersistence().findAll(); 353 } 354 355 /** 356 * Returns a range of all the user tracker paths. 357 * 358 * <p> 359 * 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 UserTrackerPathModelImpl}. 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. 360 * </p> 361 * 362 * @param start the lower bound of the range of user tracker paths 363 * @param end the upper bound of the range of user tracker paths (not inclusive) 364 * @return the range of user tracker paths 365 */ 366 public static List<UserTrackerPath> findAll(int start, int end) { 367 return getPersistence().findAll(start, end); 368 } 369 370 /** 371 * Returns an ordered range of all the user tracker paths. 372 * 373 * <p> 374 * 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 UserTrackerPathModelImpl}. 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. 375 * </p> 376 * 377 * @param start the lower bound of the range of user tracker paths 378 * @param end the upper bound of the range of user tracker paths (not inclusive) 379 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 380 * @return the ordered range of user tracker paths 381 */ 382 public static List<UserTrackerPath> findAll(int start, int end, 383 OrderByComparator<UserTrackerPath> orderByComparator) { 384 return getPersistence().findAll(start, end, orderByComparator); 385 } 386 387 /** 388 * Returns an ordered range of all the user tracker paths. 389 * 390 * <p> 391 * 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 UserTrackerPathModelImpl}. 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. 392 * </p> 393 * 394 * @param start the lower bound of the range of user tracker paths 395 * @param end the upper bound of the range of user tracker paths (not inclusive) 396 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 397 * @param retrieveFromCache whether to retrieve from the finder cache 398 * @return the ordered range of user tracker paths 399 */ 400 public static List<UserTrackerPath> findAll(int start, int end, 401 OrderByComparator<UserTrackerPath> orderByComparator, 402 boolean retrieveFromCache) { 403 return getPersistence() 404 .findAll(start, end, orderByComparator, retrieveFromCache); 405 } 406 407 /** 408 * Removes all the user tracker paths from the database. 409 */ 410 public static void removeAll() { 411 getPersistence().removeAll(); 412 } 413 414 /** 415 * Returns the number of user tracker paths. 416 * 417 * @return the number of user tracker paths 418 */ 419 public static int countAll() { 420 return getPersistence().countAll(); 421 } 422 423 public static java.util.Set<java.lang.String> getBadColumnNames() { 424 return getPersistence().getBadColumnNames(); 425 } 426 427 public static UserTrackerPathPersistence getPersistence() { 428 if (_persistence == null) { 429 _persistence = (UserTrackerPathPersistence)PortalBeanLocatorUtil.locate(UserTrackerPathPersistence.class.getName()); 430 431 ReferenceRegistry.registerReference(UserTrackerPathUtil.class, 432 "_persistence"); 433 } 434 435 return _persistence; 436 } 437 438 private static UserTrackerPathPersistence _persistence; 439 }