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.portlet.documentlibrary.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.service.ServiceContext;
024    
025    import com.liferay.portlet.documentlibrary.model.DLFileRank;
026    
027    import java.util.List;
028    
029    /**
030     * The persistence utility for the document library file rank service. This utility wraps {@link com.liferay.portlet.documentlibrary.service.persistence.impl.DLFileRankPersistenceImpl} 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.
031     *
032     * <p>
033     * Caching information and settings can be found in <code>portal.properties</code>
034     * </p>
035     *
036     * @author Brian Wing Shun Chan
037     * @see DLFileRankPersistence
038     * @see com.liferay.portlet.documentlibrary.service.persistence.impl.DLFileRankPersistenceImpl
039     * @generated
040     */
041    @ProviderType
042    public class DLFileRankUtil {
043            /*
044             * NOTE FOR DEVELOPERS:
045             *
046             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
047             */
048    
049            /**
050             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
051             */
052            public static void clearCache() {
053                    getPersistence().clearCache();
054            }
055    
056            /**
057             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
058             */
059            public static void clearCache(DLFileRank dlFileRank) {
060                    getPersistence().clearCache(dlFileRank);
061            }
062    
063            /**
064             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
065             */
066            public static long countWithDynamicQuery(DynamicQuery dynamicQuery) {
067                    return getPersistence().countWithDynamicQuery(dynamicQuery);
068            }
069    
070            /**
071             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
072             */
073            public static List<DLFileRank> findWithDynamicQuery(
074                    DynamicQuery dynamicQuery) {
075                    return getPersistence().findWithDynamicQuery(dynamicQuery);
076            }
077    
078            /**
079             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
080             */
081            public static List<DLFileRank> findWithDynamicQuery(
082                    DynamicQuery dynamicQuery, int start, int end) {
083                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
084            }
085    
086            /**
087             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
088             */
089            public static List<DLFileRank> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator<DLFileRank> orderByComparator) {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
099             */
100            public static DLFileRank update(DLFileRank dlFileRank) {
101                    return getPersistence().update(dlFileRank);
102            }
103    
104            /**
105             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
106             */
107            public static DLFileRank update(DLFileRank dlFileRank,
108                    ServiceContext serviceContext) {
109                    return getPersistence().update(dlFileRank, serviceContext);
110            }
111    
112            /**
113            * Returns all the document library file ranks where userId = &#63;.
114            *
115            * @param userId the user ID
116            * @return the matching document library file ranks
117            */
118            public static List<DLFileRank> findByUserId(long userId) {
119                    return getPersistence().findByUserId(userId);
120            }
121    
122            /**
123            * Returns a range of all the document library file ranks where userId = &#63;.
124            *
125            * <p>
126            * 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 DLFileRankModelImpl}. 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.
127            * </p>
128            *
129            * @param userId the user ID
130            * @param start the lower bound of the range of document library file ranks
131            * @param end the upper bound of the range of document library file ranks (not inclusive)
132            * @return the range of matching document library file ranks
133            */
134            public static List<DLFileRank> findByUserId(long userId, int start, int end) {
135                    return getPersistence().findByUserId(userId, start, end);
136            }
137    
138            /**
139            * Returns an ordered range of all the document library file ranks where userId = &#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 DLFileRankModelImpl}. 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 userId the user ID
146            * @param start the lower bound of the range of document library file ranks
147            * @param end the upper bound of the range of document library file ranks (not inclusive)
148            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
149            * @return the ordered range of matching document library file ranks
150            */
151            public static List<DLFileRank> findByUserId(long userId, int start,
152                    int end, OrderByComparator<DLFileRank> orderByComparator) {
153                    return getPersistence()
154                                       .findByUserId(userId, start, end, orderByComparator);
155            }
156    
157            /**
158            * Returns an ordered range of all the document library file ranks where userId = &#63;.
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 DLFileRankModelImpl}. 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 userId the user ID
165            * @param start the lower bound of the range of document library file ranks
166            * @param end the upper bound of the range of document library file ranks (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 document library file ranks
170            */
171            public static List<DLFileRank> findByUserId(long userId, int start,
172                    int end, OrderByComparator<DLFileRank> orderByComparator,
173                    boolean retrieveFromCache) {
174                    return getPersistence()
175                                       .findByUserId(userId, start, end, orderByComparator,
176                            retrieveFromCache);
177            }
178    
179            /**
180            * Returns the first document library file rank in the ordered set where userId = &#63;.
181            *
182            * @param userId the user ID
183            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
184            * @return the first matching document library file rank
185            * @throws NoSuchFileRankException if a matching document library file rank could not be found
186            */
187            public static DLFileRank findByUserId_First(long userId,
188                    OrderByComparator<DLFileRank> orderByComparator)
189                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileRankException {
190                    return getPersistence().findByUserId_First(userId, orderByComparator);
191            }
192    
193            /**
194            * Returns the first document library file rank in the ordered set where userId = &#63;.
195            *
196            * @param userId the user ID
197            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
198            * @return the first matching document library file rank, or <code>null</code> if a matching document library file rank could not be found
199            */
200            public static DLFileRank fetchByUserId_First(long userId,
201                    OrderByComparator<DLFileRank> orderByComparator) {
202                    return getPersistence().fetchByUserId_First(userId, orderByComparator);
203            }
204    
205            /**
206            * Returns the last document library file rank in the ordered set where userId = &#63;.
207            *
208            * @param userId the user ID
209            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
210            * @return the last matching document library file rank
211            * @throws NoSuchFileRankException if a matching document library file rank could not be found
212            */
213            public static DLFileRank findByUserId_Last(long userId,
214                    OrderByComparator<DLFileRank> orderByComparator)
215                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileRankException {
216                    return getPersistence().findByUserId_Last(userId, orderByComparator);
217            }
218    
219            /**
220            * Returns the last document library file rank in the ordered set where userId = &#63;.
221            *
222            * @param userId the user ID
223            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
224            * @return the last matching document library file rank, or <code>null</code> if a matching document library file rank could not be found
225            */
226            public static DLFileRank fetchByUserId_Last(long userId,
227                    OrderByComparator<DLFileRank> orderByComparator) {
228                    return getPersistence().fetchByUserId_Last(userId, orderByComparator);
229            }
230    
231            /**
232            * Returns the document library file ranks before and after the current document library file rank in the ordered set where userId = &#63;.
233            *
234            * @param fileRankId the primary key of the current document library file rank
235            * @param userId the user ID
236            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
237            * @return the previous, current, and next document library file rank
238            * @throws NoSuchFileRankException if a document library file rank with the primary key could not be found
239            */
240            public static DLFileRank[] findByUserId_PrevAndNext(long fileRankId,
241                    long userId, OrderByComparator<DLFileRank> orderByComparator)
242                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileRankException {
243                    return getPersistence()
244                                       .findByUserId_PrevAndNext(fileRankId, userId,
245                            orderByComparator);
246            }
247    
248            /**
249            * Removes all the document library file ranks where userId = &#63; from the database.
250            *
251            * @param userId the user ID
252            */
253            public static void removeByUserId(long userId) {
254                    getPersistence().removeByUserId(userId);
255            }
256    
257            /**
258            * Returns the number of document library file ranks where userId = &#63;.
259            *
260            * @param userId the user ID
261            * @return the number of matching document library file ranks
262            */
263            public static int countByUserId(long userId) {
264                    return getPersistence().countByUserId(userId);
265            }
266    
267            /**
268            * Returns all the document library file ranks where fileEntryId = &#63;.
269            *
270            * @param fileEntryId the file entry ID
271            * @return the matching document library file ranks
272            */
273            public static List<DLFileRank> findByFileEntryId(long fileEntryId) {
274                    return getPersistence().findByFileEntryId(fileEntryId);
275            }
276    
277            /**
278            * Returns a range of all the document library file ranks where fileEntryId = &#63;.
279            *
280            * <p>
281            * 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 DLFileRankModelImpl}. 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.
282            * </p>
283            *
284            * @param fileEntryId the file entry ID
285            * @param start the lower bound of the range of document library file ranks
286            * @param end the upper bound of the range of document library file ranks (not inclusive)
287            * @return the range of matching document library file ranks
288            */
289            public static List<DLFileRank> findByFileEntryId(long fileEntryId,
290                    int start, int end) {
291                    return getPersistence().findByFileEntryId(fileEntryId, start, end);
292            }
293    
294            /**
295            * Returns an ordered range of all the document library file ranks where fileEntryId = &#63;.
296            *
297            * <p>
298            * 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 DLFileRankModelImpl}. 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.
299            * </p>
300            *
301            * @param fileEntryId the file entry ID
302            * @param start the lower bound of the range of document library file ranks
303            * @param end the upper bound of the range of document library file ranks (not inclusive)
304            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
305            * @return the ordered range of matching document library file ranks
306            */
307            public static List<DLFileRank> findByFileEntryId(long fileEntryId,
308                    int start, int end, OrderByComparator<DLFileRank> orderByComparator) {
309                    return getPersistence()
310                                       .findByFileEntryId(fileEntryId, start, end, orderByComparator);
311            }
312    
313            /**
314            * Returns an ordered range of all the document library file ranks where fileEntryId = &#63;.
315            *
316            * <p>
317            * 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 DLFileRankModelImpl}. 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.
318            * </p>
319            *
320            * @param fileEntryId the file entry ID
321            * @param start the lower bound of the range of document library file ranks
322            * @param end the upper bound of the range of document library file ranks (not inclusive)
323            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
324            * @param retrieveFromCache whether to retrieve from the finder cache
325            * @return the ordered range of matching document library file ranks
326            */
327            public static List<DLFileRank> findByFileEntryId(long fileEntryId,
328                    int start, int end, OrderByComparator<DLFileRank> orderByComparator,
329                    boolean retrieveFromCache) {
330                    return getPersistence()
331                                       .findByFileEntryId(fileEntryId, start, end,
332                            orderByComparator, retrieveFromCache);
333            }
334    
335            /**
336            * Returns the first document library file rank in the ordered set where fileEntryId = &#63;.
337            *
338            * @param fileEntryId the file entry ID
339            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
340            * @return the first matching document library file rank
341            * @throws NoSuchFileRankException if a matching document library file rank could not be found
342            */
343            public static DLFileRank findByFileEntryId_First(long fileEntryId,
344                    OrderByComparator<DLFileRank> orderByComparator)
345                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileRankException {
346                    return getPersistence()
347                                       .findByFileEntryId_First(fileEntryId, orderByComparator);
348            }
349    
350            /**
351            * Returns the first document library file rank in the ordered set where fileEntryId = &#63;.
352            *
353            * @param fileEntryId the file entry ID
354            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
355            * @return the first matching document library file rank, or <code>null</code> if a matching document library file rank could not be found
356            */
357            public static DLFileRank fetchByFileEntryId_First(long fileEntryId,
358                    OrderByComparator<DLFileRank> orderByComparator) {
359                    return getPersistence()
360                                       .fetchByFileEntryId_First(fileEntryId, orderByComparator);
361            }
362    
363            /**
364            * Returns the last document library file rank in the ordered set where fileEntryId = &#63;.
365            *
366            * @param fileEntryId the file entry ID
367            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
368            * @return the last matching document library file rank
369            * @throws NoSuchFileRankException if a matching document library file rank could not be found
370            */
371            public static DLFileRank findByFileEntryId_Last(long fileEntryId,
372                    OrderByComparator<DLFileRank> orderByComparator)
373                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileRankException {
374                    return getPersistence()
375                                       .findByFileEntryId_Last(fileEntryId, orderByComparator);
376            }
377    
378            /**
379            * Returns the last document library file rank in the ordered set where fileEntryId = &#63;.
380            *
381            * @param fileEntryId the file entry ID
382            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
383            * @return the last matching document library file rank, or <code>null</code> if a matching document library file rank could not be found
384            */
385            public static DLFileRank fetchByFileEntryId_Last(long fileEntryId,
386                    OrderByComparator<DLFileRank> orderByComparator) {
387                    return getPersistence()
388                                       .fetchByFileEntryId_Last(fileEntryId, orderByComparator);
389            }
390    
391            /**
392            * Returns the document library file ranks before and after the current document library file rank in the ordered set where fileEntryId = &#63;.
393            *
394            * @param fileRankId the primary key of the current document library file rank
395            * @param fileEntryId the file entry ID
396            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
397            * @return the previous, current, and next document library file rank
398            * @throws NoSuchFileRankException if a document library file rank with the primary key could not be found
399            */
400            public static DLFileRank[] findByFileEntryId_PrevAndNext(long fileRankId,
401                    long fileEntryId, OrderByComparator<DLFileRank> orderByComparator)
402                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileRankException {
403                    return getPersistence()
404                                       .findByFileEntryId_PrevAndNext(fileRankId, fileEntryId,
405                            orderByComparator);
406            }
407    
408            /**
409            * Removes all the document library file ranks where fileEntryId = &#63; from the database.
410            *
411            * @param fileEntryId the file entry ID
412            */
413            public static void removeByFileEntryId(long fileEntryId) {
414                    getPersistence().removeByFileEntryId(fileEntryId);
415            }
416    
417            /**
418            * Returns the number of document library file ranks where fileEntryId = &#63;.
419            *
420            * @param fileEntryId the file entry ID
421            * @return the number of matching document library file ranks
422            */
423            public static int countByFileEntryId(long fileEntryId) {
424                    return getPersistence().countByFileEntryId(fileEntryId);
425            }
426    
427            /**
428            * Returns all the document library file ranks where groupId = &#63; and userId = &#63;.
429            *
430            * @param groupId the group ID
431            * @param userId the user ID
432            * @return the matching document library file ranks
433            */
434            public static List<DLFileRank> findByG_U(long groupId, long userId) {
435                    return getPersistence().findByG_U(groupId, userId);
436            }
437    
438            /**
439            * Returns a range of all the document library file ranks where groupId = &#63; and userId = &#63;.
440            *
441            * <p>
442            * 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 DLFileRankModelImpl}. 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.
443            * </p>
444            *
445            * @param groupId the group ID
446            * @param userId the user ID
447            * @param start the lower bound of the range of document library file ranks
448            * @param end the upper bound of the range of document library file ranks (not inclusive)
449            * @return the range of matching document library file ranks
450            */
451            public static List<DLFileRank> findByG_U(long groupId, long userId,
452                    int start, int end) {
453                    return getPersistence().findByG_U(groupId, userId, start, end);
454            }
455    
456            /**
457            * Returns an ordered range of all the document library file ranks where groupId = &#63; and userId = &#63;.
458            *
459            * <p>
460            * 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 DLFileRankModelImpl}. 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.
461            * </p>
462            *
463            * @param groupId the group ID
464            * @param userId the user ID
465            * @param start the lower bound of the range of document library file ranks
466            * @param end the upper bound of the range of document library file ranks (not inclusive)
467            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
468            * @return the ordered range of matching document library file ranks
469            */
470            public static List<DLFileRank> findByG_U(long groupId, long userId,
471                    int start, int end, OrderByComparator<DLFileRank> orderByComparator) {
472                    return getPersistence()
473                                       .findByG_U(groupId, userId, start, end, orderByComparator);
474            }
475    
476            /**
477            * Returns an ordered range of all the document library file ranks where groupId = &#63; and userId = &#63;.
478            *
479            * <p>
480            * 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 DLFileRankModelImpl}. 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.
481            * </p>
482            *
483            * @param groupId the group ID
484            * @param userId the user ID
485            * @param start the lower bound of the range of document library file ranks
486            * @param end the upper bound of the range of document library file ranks (not inclusive)
487            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
488            * @param retrieveFromCache whether to retrieve from the finder cache
489            * @return the ordered range of matching document library file ranks
490            */
491            public static List<DLFileRank> findByG_U(long groupId, long userId,
492                    int start, int end, OrderByComparator<DLFileRank> orderByComparator,
493                    boolean retrieveFromCache) {
494                    return getPersistence()
495                                       .findByG_U(groupId, userId, start, end, orderByComparator,
496                            retrieveFromCache);
497            }
498    
499            /**
500            * Returns the first document library file rank in the ordered set where groupId = &#63; and userId = &#63;.
501            *
502            * @param groupId the group ID
503            * @param userId the user ID
504            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
505            * @return the first matching document library file rank
506            * @throws NoSuchFileRankException if a matching document library file rank could not be found
507            */
508            public static DLFileRank findByG_U_First(long groupId, long userId,
509                    OrderByComparator<DLFileRank> orderByComparator)
510                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileRankException {
511                    return getPersistence()
512                                       .findByG_U_First(groupId, userId, orderByComparator);
513            }
514    
515            /**
516            * Returns the first document library file rank in the ordered set where groupId = &#63; and userId = &#63;.
517            *
518            * @param groupId the group ID
519            * @param userId the user ID
520            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
521            * @return the first matching document library file rank, or <code>null</code> if a matching document library file rank could not be found
522            */
523            public static DLFileRank fetchByG_U_First(long groupId, long userId,
524                    OrderByComparator<DLFileRank> orderByComparator) {
525                    return getPersistence()
526                                       .fetchByG_U_First(groupId, userId, orderByComparator);
527            }
528    
529            /**
530            * Returns the last document library file rank in the ordered set where groupId = &#63; and userId = &#63;.
531            *
532            * @param groupId the group ID
533            * @param userId the user ID
534            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
535            * @return the last matching document library file rank
536            * @throws NoSuchFileRankException if a matching document library file rank could not be found
537            */
538            public static DLFileRank findByG_U_Last(long groupId, long userId,
539                    OrderByComparator<DLFileRank> orderByComparator)
540                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileRankException {
541                    return getPersistence()
542                                       .findByG_U_Last(groupId, userId, orderByComparator);
543            }
544    
545            /**
546            * Returns the last document library file rank in the ordered set where groupId = &#63; and userId = &#63;.
547            *
548            * @param groupId the group ID
549            * @param userId the user ID
550            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
551            * @return the last matching document library file rank, or <code>null</code> if a matching document library file rank could not be found
552            */
553            public static DLFileRank fetchByG_U_Last(long groupId, long userId,
554                    OrderByComparator<DLFileRank> orderByComparator) {
555                    return getPersistence()
556                                       .fetchByG_U_Last(groupId, userId, orderByComparator);
557            }
558    
559            /**
560            * Returns the document library file ranks before and after the current document library file rank in the ordered set where groupId = &#63; and userId = &#63;.
561            *
562            * @param fileRankId the primary key of the current document library file rank
563            * @param groupId the group ID
564            * @param userId the user ID
565            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
566            * @return the previous, current, and next document library file rank
567            * @throws NoSuchFileRankException if a document library file rank with the primary key could not be found
568            */
569            public static DLFileRank[] findByG_U_PrevAndNext(long fileRankId,
570                    long groupId, long userId,
571                    OrderByComparator<DLFileRank> orderByComparator)
572                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileRankException {
573                    return getPersistence()
574                                       .findByG_U_PrevAndNext(fileRankId, groupId, userId,
575                            orderByComparator);
576            }
577    
578            /**
579            * Removes all the document library file ranks where groupId = &#63; and userId = &#63; from the database.
580            *
581            * @param groupId the group ID
582            * @param userId the user ID
583            */
584            public static void removeByG_U(long groupId, long userId) {
585                    getPersistence().removeByG_U(groupId, userId);
586            }
587    
588            /**
589            * Returns the number of document library file ranks where groupId = &#63; and userId = &#63;.
590            *
591            * @param groupId the group ID
592            * @param userId the user ID
593            * @return the number of matching document library file ranks
594            */
595            public static int countByG_U(long groupId, long userId) {
596                    return getPersistence().countByG_U(groupId, userId);
597            }
598    
599            /**
600            * Returns all the document library file ranks where groupId = &#63; and userId = &#63; and active = &#63;.
601            *
602            * @param groupId the group ID
603            * @param userId the user ID
604            * @param active the active
605            * @return the matching document library file ranks
606            */
607            public static List<DLFileRank> findByG_U_A(long groupId, long userId,
608                    boolean active) {
609                    return getPersistence().findByG_U_A(groupId, userId, active);
610            }
611    
612            /**
613            * Returns a range of all the document library file ranks where groupId = &#63; and userId = &#63; and active = &#63;.
614            *
615            * <p>
616            * 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 DLFileRankModelImpl}. 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.
617            * </p>
618            *
619            * @param groupId the group ID
620            * @param userId the user ID
621            * @param active the active
622            * @param start the lower bound of the range of document library file ranks
623            * @param end the upper bound of the range of document library file ranks (not inclusive)
624            * @return the range of matching document library file ranks
625            */
626            public static List<DLFileRank> findByG_U_A(long groupId, long userId,
627                    boolean active, int start, int end) {
628                    return getPersistence().findByG_U_A(groupId, userId, active, start, end);
629            }
630    
631            /**
632            * Returns an ordered range of all the document library file ranks where groupId = &#63; and userId = &#63; and active = &#63;.
633            *
634            * <p>
635            * 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 DLFileRankModelImpl}. 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.
636            * </p>
637            *
638            * @param groupId the group ID
639            * @param userId the user ID
640            * @param active the active
641            * @param start the lower bound of the range of document library file ranks
642            * @param end the upper bound of the range of document library file ranks (not inclusive)
643            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
644            * @return the ordered range of matching document library file ranks
645            */
646            public static List<DLFileRank> findByG_U_A(long groupId, long userId,
647                    boolean active, int start, int end,
648                    OrderByComparator<DLFileRank> orderByComparator) {
649                    return getPersistence()
650                                       .findByG_U_A(groupId, userId, active, start, end,
651                            orderByComparator);
652            }
653    
654            /**
655            * Returns an ordered range of all the document library file ranks where groupId = &#63; and userId = &#63; and active = &#63;.
656            *
657            * <p>
658            * 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 DLFileRankModelImpl}. 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.
659            * </p>
660            *
661            * @param groupId the group ID
662            * @param userId the user ID
663            * @param active the active
664            * @param start the lower bound of the range of document library file ranks
665            * @param end the upper bound of the range of document library file ranks (not inclusive)
666            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
667            * @param retrieveFromCache whether to retrieve from the finder cache
668            * @return the ordered range of matching document library file ranks
669            */
670            public static List<DLFileRank> findByG_U_A(long groupId, long userId,
671                    boolean active, int start, int end,
672                    OrderByComparator<DLFileRank> orderByComparator,
673                    boolean retrieveFromCache) {
674                    return getPersistence()
675                                       .findByG_U_A(groupId, userId, active, start, end,
676                            orderByComparator, retrieveFromCache);
677            }
678    
679            /**
680            * Returns the first document library file rank in the ordered set where groupId = &#63; and userId = &#63; and active = &#63;.
681            *
682            * @param groupId the group ID
683            * @param userId the user ID
684            * @param active the active
685            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
686            * @return the first matching document library file rank
687            * @throws NoSuchFileRankException if a matching document library file rank could not be found
688            */
689            public static DLFileRank findByG_U_A_First(long groupId, long userId,
690                    boolean active, OrderByComparator<DLFileRank> orderByComparator)
691                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileRankException {
692                    return getPersistence()
693                                       .findByG_U_A_First(groupId, userId, active, orderByComparator);
694            }
695    
696            /**
697            * Returns the first document library file rank in the ordered set where groupId = &#63; and userId = &#63; and active = &#63;.
698            *
699            * @param groupId the group ID
700            * @param userId the user ID
701            * @param active the active
702            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
703            * @return the first matching document library file rank, or <code>null</code> if a matching document library file rank could not be found
704            */
705            public static DLFileRank fetchByG_U_A_First(long groupId, long userId,
706                    boolean active, OrderByComparator<DLFileRank> orderByComparator) {
707                    return getPersistence()
708                                       .fetchByG_U_A_First(groupId, userId, active,
709                            orderByComparator);
710            }
711    
712            /**
713            * Returns the last document library file rank in the ordered set where groupId = &#63; and userId = &#63; and active = &#63;.
714            *
715            * @param groupId the group ID
716            * @param userId the user ID
717            * @param active the active
718            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
719            * @return the last matching document library file rank
720            * @throws NoSuchFileRankException if a matching document library file rank could not be found
721            */
722            public static DLFileRank findByG_U_A_Last(long groupId, long userId,
723                    boolean active, OrderByComparator<DLFileRank> orderByComparator)
724                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileRankException {
725                    return getPersistence()
726                                       .findByG_U_A_Last(groupId, userId, active, orderByComparator);
727            }
728    
729            /**
730            * Returns the last document library file rank in the ordered set where groupId = &#63; and userId = &#63; and active = &#63;.
731            *
732            * @param groupId the group ID
733            * @param userId the user ID
734            * @param active the active
735            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
736            * @return the last matching document library file rank, or <code>null</code> if a matching document library file rank could not be found
737            */
738            public static DLFileRank fetchByG_U_A_Last(long groupId, long userId,
739                    boolean active, OrderByComparator<DLFileRank> orderByComparator) {
740                    return getPersistence()
741                                       .fetchByG_U_A_Last(groupId, userId, active, orderByComparator);
742            }
743    
744            /**
745            * Returns the document library file ranks before and after the current document library file rank in the ordered set where groupId = &#63; and userId = &#63; and active = &#63;.
746            *
747            * @param fileRankId the primary key of the current document library file rank
748            * @param groupId the group ID
749            * @param userId the user ID
750            * @param active the active
751            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
752            * @return the previous, current, and next document library file rank
753            * @throws NoSuchFileRankException if a document library file rank with the primary key could not be found
754            */
755            public static DLFileRank[] findByG_U_A_PrevAndNext(long fileRankId,
756                    long groupId, long userId, boolean active,
757                    OrderByComparator<DLFileRank> orderByComparator)
758                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileRankException {
759                    return getPersistence()
760                                       .findByG_U_A_PrevAndNext(fileRankId, groupId, userId,
761                            active, orderByComparator);
762            }
763    
764            /**
765            * Removes all the document library file ranks where groupId = &#63; and userId = &#63; and active = &#63; from the database.
766            *
767            * @param groupId the group ID
768            * @param userId the user ID
769            * @param active the active
770            */
771            public static void removeByG_U_A(long groupId, long userId, boolean active) {
772                    getPersistence().removeByG_U_A(groupId, userId, active);
773            }
774    
775            /**
776            * Returns the number of document library file ranks where groupId = &#63; and userId = &#63; and active = &#63;.
777            *
778            * @param groupId the group ID
779            * @param userId the user ID
780            * @param active the active
781            * @return the number of matching document library file ranks
782            */
783            public static int countByG_U_A(long groupId, long userId, boolean active) {
784                    return getPersistence().countByG_U_A(groupId, userId, active);
785            }
786    
787            /**
788            * Returns the document library file rank where companyId = &#63; and userId = &#63; and fileEntryId = &#63; or throws a {@link NoSuchFileRankException} if it could not be found.
789            *
790            * @param companyId the company ID
791            * @param userId the user ID
792            * @param fileEntryId the file entry ID
793            * @return the matching document library file rank
794            * @throws NoSuchFileRankException if a matching document library file rank could not be found
795            */
796            public static DLFileRank findByC_U_F(long companyId, long userId,
797                    long fileEntryId)
798                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileRankException {
799                    return getPersistence().findByC_U_F(companyId, userId, fileEntryId);
800            }
801    
802            /**
803            * Returns the document library file rank where companyId = &#63; and userId = &#63; and fileEntryId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
804            *
805            * @param companyId the company ID
806            * @param userId the user ID
807            * @param fileEntryId the file entry ID
808            * @return the matching document library file rank, or <code>null</code> if a matching document library file rank could not be found
809            */
810            public static DLFileRank fetchByC_U_F(long companyId, long userId,
811                    long fileEntryId) {
812                    return getPersistence().fetchByC_U_F(companyId, userId, fileEntryId);
813            }
814    
815            /**
816            * Returns the document library file rank where companyId = &#63; and userId = &#63; and fileEntryId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
817            *
818            * @param companyId the company ID
819            * @param userId the user ID
820            * @param fileEntryId the file entry ID
821            * @param retrieveFromCache whether to retrieve from the finder cache
822            * @return the matching document library file rank, or <code>null</code> if a matching document library file rank could not be found
823            */
824            public static DLFileRank fetchByC_U_F(long companyId, long userId,
825                    long fileEntryId, boolean retrieveFromCache) {
826                    return getPersistence()
827                                       .fetchByC_U_F(companyId, userId, fileEntryId,
828                            retrieveFromCache);
829            }
830    
831            /**
832            * Removes the document library file rank where companyId = &#63; and userId = &#63; and fileEntryId = &#63; from the database.
833            *
834            * @param companyId the company ID
835            * @param userId the user ID
836            * @param fileEntryId the file entry ID
837            * @return the document library file rank that was removed
838            */
839            public static DLFileRank removeByC_U_F(long companyId, long userId,
840                    long fileEntryId)
841                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileRankException {
842                    return getPersistence().removeByC_U_F(companyId, userId, fileEntryId);
843            }
844    
845            /**
846            * Returns the number of document library file ranks where companyId = &#63; and userId = &#63; and fileEntryId = &#63;.
847            *
848            * @param companyId the company ID
849            * @param userId the user ID
850            * @param fileEntryId the file entry ID
851            * @return the number of matching document library file ranks
852            */
853            public static int countByC_U_F(long companyId, long userId, long fileEntryId) {
854                    return getPersistence().countByC_U_F(companyId, userId, fileEntryId);
855            }
856    
857            /**
858            * Caches the document library file rank in the entity cache if it is enabled.
859            *
860            * @param dlFileRank the document library file rank
861            */
862            public static void cacheResult(DLFileRank dlFileRank) {
863                    getPersistence().cacheResult(dlFileRank);
864            }
865    
866            /**
867            * Caches the document library file ranks in the entity cache if it is enabled.
868            *
869            * @param dlFileRanks the document library file ranks
870            */
871            public static void cacheResult(List<DLFileRank> dlFileRanks) {
872                    getPersistence().cacheResult(dlFileRanks);
873            }
874    
875            /**
876            * Creates a new document library file rank with the primary key. Does not add the document library file rank to the database.
877            *
878            * @param fileRankId the primary key for the new document library file rank
879            * @return the new document library file rank
880            */
881            public static DLFileRank create(long fileRankId) {
882                    return getPersistence().create(fileRankId);
883            }
884    
885            /**
886            * Removes the document library file rank with the primary key from the database. Also notifies the appropriate model listeners.
887            *
888            * @param fileRankId the primary key of the document library file rank
889            * @return the document library file rank that was removed
890            * @throws NoSuchFileRankException if a document library file rank with the primary key could not be found
891            */
892            public static DLFileRank remove(long fileRankId)
893                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileRankException {
894                    return getPersistence().remove(fileRankId);
895            }
896    
897            public static DLFileRank updateImpl(DLFileRank dlFileRank) {
898                    return getPersistence().updateImpl(dlFileRank);
899            }
900    
901            /**
902            * Returns the document library file rank with the primary key or throws a {@link NoSuchFileRankException} if it could not be found.
903            *
904            * @param fileRankId the primary key of the document library file rank
905            * @return the document library file rank
906            * @throws NoSuchFileRankException if a document library file rank with the primary key could not be found
907            */
908            public static DLFileRank findByPrimaryKey(long fileRankId)
909                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileRankException {
910                    return getPersistence().findByPrimaryKey(fileRankId);
911            }
912    
913            /**
914            * Returns the document library file rank with the primary key or returns <code>null</code> if it could not be found.
915            *
916            * @param fileRankId the primary key of the document library file rank
917            * @return the document library file rank, or <code>null</code> if a document library file rank with the primary key could not be found
918            */
919            public static DLFileRank fetchByPrimaryKey(long fileRankId) {
920                    return getPersistence().fetchByPrimaryKey(fileRankId);
921            }
922    
923            public static java.util.Map<java.io.Serializable, DLFileRank> fetchByPrimaryKeys(
924                    java.util.Set<java.io.Serializable> primaryKeys) {
925                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
926            }
927    
928            /**
929            * Returns all the document library file ranks.
930            *
931            * @return the document library file ranks
932            */
933            public static List<DLFileRank> findAll() {
934                    return getPersistence().findAll();
935            }
936    
937            /**
938            * Returns a range of all the document library file ranks.
939            *
940            * <p>
941            * 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 DLFileRankModelImpl}. 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.
942            * </p>
943            *
944            * @param start the lower bound of the range of document library file ranks
945            * @param end the upper bound of the range of document library file ranks (not inclusive)
946            * @return the range of document library file ranks
947            */
948            public static List<DLFileRank> findAll(int start, int end) {
949                    return getPersistence().findAll(start, end);
950            }
951    
952            /**
953            * Returns an ordered range of all the document library file ranks.
954            *
955            * <p>
956            * 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 DLFileRankModelImpl}. 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.
957            * </p>
958            *
959            * @param start the lower bound of the range of document library file ranks
960            * @param end the upper bound of the range of document library file ranks (not inclusive)
961            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
962            * @return the ordered range of document library file ranks
963            */
964            public static List<DLFileRank> findAll(int start, int end,
965                    OrderByComparator<DLFileRank> orderByComparator) {
966                    return getPersistence().findAll(start, end, orderByComparator);
967            }
968    
969            /**
970            * Returns an ordered range of all the document library file ranks.
971            *
972            * <p>
973            * 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 DLFileRankModelImpl}. 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.
974            * </p>
975            *
976            * @param start the lower bound of the range of document library file ranks
977            * @param end the upper bound of the range of document library file ranks (not inclusive)
978            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
979            * @param retrieveFromCache whether to retrieve from the finder cache
980            * @return the ordered range of document library file ranks
981            */
982            public static List<DLFileRank> findAll(int start, int end,
983                    OrderByComparator<DLFileRank> orderByComparator,
984                    boolean retrieveFromCache) {
985                    return getPersistence()
986                                       .findAll(start, end, orderByComparator, retrieveFromCache);
987            }
988    
989            /**
990            * Removes all the document library file ranks from the database.
991            */
992            public static void removeAll() {
993                    getPersistence().removeAll();
994            }
995    
996            /**
997            * Returns the number of document library file ranks.
998            *
999            * @return the number of document library file ranks
1000            */
1001            public static int countAll() {
1002                    return getPersistence().countAll();
1003            }
1004    
1005            public static java.util.Set<java.lang.String> getBadColumnNames() {
1006                    return getPersistence().getBadColumnNames();
1007            }
1008    
1009            public static DLFileRankPersistence getPersistence() {
1010                    if (_persistence == null) {
1011                            _persistence = (DLFileRankPersistence)PortalBeanLocatorUtil.locate(DLFileRankPersistence.class.getName());
1012    
1013                            ReferenceRegistry.registerReference(DLFileRankUtil.class,
1014                                    "_persistence");
1015                    }
1016    
1017                    return _persistence;
1018            }
1019    
1020            private static DLFileRankPersistence _persistence;
1021    }