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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63; 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 = &#63;.
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    }