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.DLFileVersion;
026    
027    import java.util.List;
028    
029    /**
030     * The persistence utility for the document library file version service. This utility wraps {@link com.liferay.portlet.documentlibrary.service.persistence.impl.DLFileVersionPersistenceImpl} 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 DLFileVersionPersistence
038     * @see com.liferay.portlet.documentlibrary.service.persistence.impl.DLFileVersionPersistenceImpl
039     * @generated
040     */
041    @ProviderType
042    public class DLFileVersionUtil {
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(DLFileVersion dlFileVersion) {
060                    getPersistence().clearCache(dlFileVersion);
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<DLFileVersion> 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<DLFileVersion> 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<DLFileVersion> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator<DLFileVersion> 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 DLFileVersion update(DLFileVersion dlFileVersion) {
101                    return getPersistence().update(dlFileVersion);
102            }
103    
104            /**
105             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
106             */
107            public static DLFileVersion update(DLFileVersion dlFileVersion,
108                    ServiceContext serviceContext) {
109                    return getPersistence().update(dlFileVersion, serviceContext);
110            }
111    
112            /**
113            * Returns all the document library file versions where uuid = &#63;.
114            *
115            * @param uuid the uuid
116            * @return the matching document library file versions
117            */
118            public static List<DLFileVersion> findByUuid(java.lang.String uuid) {
119                    return getPersistence().findByUuid(uuid);
120            }
121    
122            /**
123            * Returns a range of all the document library file versions where uuid = &#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 DLFileVersionModelImpl}. 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 uuid the uuid
130            * @param start the lower bound of the range of document library file versions
131            * @param end the upper bound of the range of document library file versions (not inclusive)
132            * @return the range of matching document library file versions
133            */
134            public static List<DLFileVersion> findByUuid(java.lang.String uuid,
135                    int start, int end) {
136                    return getPersistence().findByUuid(uuid, start, end);
137            }
138    
139            /**
140            * Returns an ordered range of all the document library file versions where uuid = &#63;.
141            *
142            * <p>
143            * 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 DLFileVersionModelImpl}. 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.
144            * </p>
145            *
146            * @param uuid the uuid
147            * @param start the lower bound of the range of document library file versions
148            * @param end the upper bound of the range of document library file versions (not inclusive)
149            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
150            * @return the ordered range of matching document library file versions
151            */
152            public static List<DLFileVersion> findByUuid(java.lang.String uuid,
153                    int start, int end, OrderByComparator<DLFileVersion> orderByComparator) {
154                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
155            }
156    
157            /**
158            * Returns an ordered range of all the document library file versions where uuid = &#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 DLFileVersionModelImpl}. 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 uuid the uuid
165            * @param start the lower bound of the range of document library file versions
166            * @param end the upper bound of the range of document library file versions (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 versions
170            */
171            public static List<DLFileVersion> findByUuid(java.lang.String uuid,
172                    int start, int end, OrderByComparator<DLFileVersion> orderByComparator,
173                    boolean retrieveFromCache) {
174                    return getPersistence()
175                                       .findByUuid(uuid, start, end, orderByComparator,
176                            retrieveFromCache);
177            }
178    
179            /**
180            * Returns the first document library file version in the ordered set where uuid = &#63;.
181            *
182            * @param uuid the uuid
183            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
184            * @return the first matching document library file version
185            * @throws NoSuchFileVersionException if a matching document library file version could not be found
186            */
187            public static DLFileVersion findByUuid_First(java.lang.String uuid,
188                    OrderByComparator<DLFileVersion> orderByComparator)
189                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
190                    return getPersistence().findByUuid_First(uuid, orderByComparator);
191            }
192    
193            /**
194            * Returns the first document library file version in the ordered set where uuid = &#63;.
195            *
196            * @param uuid the uuid
197            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
198            * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found
199            */
200            public static DLFileVersion fetchByUuid_First(java.lang.String uuid,
201                    OrderByComparator<DLFileVersion> orderByComparator) {
202                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
203            }
204    
205            /**
206            * Returns the last document library file version in the ordered set where uuid = &#63;.
207            *
208            * @param uuid the uuid
209            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
210            * @return the last matching document library file version
211            * @throws NoSuchFileVersionException if a matching document library file version could not be found
212            */
213            public static DLFileVersion findByUuid_Last(java.lang.String uuid,
214                    OrderByComparator<DLFileVersion> orderByComparator)
215                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
216                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
217            }
218    
219            /**
220            * Returns the last document library file version in the ordered set where uuid = &#63;.
221            *
222            * @param uuid the uuid
223            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
224            * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found
225            */
226            public static DLFileVersion fetchByUuid_Last(java.lang.String uuid,
227                    OrderByComparator<DLFileVersion> orderByComparator) {
228                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
229            }
230    
231            /**
232            * Returns the document library file versions before and after the current document library file version in the ordered set where uuid = &#63;.
233            *
234            * @param fileVersionId the primary key of the current document library file version
235            * @param uuid the uuid
236            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
237            * @return the previous, current, and next document library file version
238            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
239            */
240            public static DLFileVersion[] findByUuid_PrevAndNext(long fileVersionId,
241                    java.lang.String uuid,
242                    OrderByComparator<DLFileVersion> orderByComparator)
243                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
244                    return getPersistence()
245                                       .findByUuid_PrevAndNext(fileVersionId, uuid,
246                            orderByComparator);
247            }
248    
249            /**
250            * Removes all the document library file versions where uuid = &#63; from the database.
251            *
252            * @param uuid the uuid
253            */
254            public static void removeByUuid(java.lang.String uuid) {
255                    getPersistence().removeByUuid(uuid);
256            }
257    
258            /**
259            * Returns the number of document library file versions where uuid = &#63;.
260            *
261            * @param uuid the uuid
262            * @return the number of matching document library file versions
263            */
264            public static int countByUuid(java.lang.String uuid) {
265                    return getPersistence().countByUuid(uuid);
266            }
267    
268            /**
269            * Returns the document library file version where uuid = &#63; and groupId = &#63; or throws a {@link NoSuchFileVersionException} if it could not be found.
270            *
271            * @param uuid the uuid
272            * @param groupId the group ID
273            * @return the matching document library file version
274            * @throws NoSuchFileVersionException if a matching document library file version could not be found
275            */
276            public static DLFileVersion findByUUID_G(java.lang.String uuid, long groupId)
277                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
278                    return getPersistence().findByUUID_G(uuid, groupId);
279            }
280    
281            /**
282            * Returns the document library file version where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
283            *
284            * @param uuid the uuid
285            * @param groupId the group ID
286            * @return the matching document library file version, or <code>null</code> if a matching document library file version could not be found
287            */
288            public static DLFileVersion fetchByUUID_G(java.lang.String uuid,
289                    long groupId) {
290                    return getPersistence().fetchByUUID_G(uuid, groupId);
291            }
292    
293            /**
294            * Returns the document library file version where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
295            *
296            * @param uuid the uuid
297            * @param groupId the group ID
298            * @param retrieveFromCache whether to retrieve from the finder cache
299            * @return the matching document library file version, or <code>null</code> if a matching document library file version could not be found
300            */
301            public static DLFileVersion fetchByUUID_G(java.lang.String uuid,
302                    long groupId, boolean retrieveFromCache) {
303                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
304            }
305    
306            /**
307            * Removes the document library file version where uuid = &#63; and groupId = &#63; from the database.
308            *
309            * @param uuid the uuid
310            * @param groupId the group ID
311            * @return the document library file version that was removed
312            */
313            public static DLFileVersion removeByUUID_G(java.lang.String uuid,
314                    long groupId)
315                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
316                    return getPersistence().removeByUUID_G(uuid, groupId);
317            }
318    
319            /**
320            * Returns the number of document library file versions where uuid = &#63; and groupId = &#63;.
321            *
322            * @param uuid the uuid
323            * @param groupId the group ID
324            * @return the number of matching document library file versions
325            */
326            public static int countByUUID_G(java.lang.String uuid, long groupId) {
327                    return getPersistence().countByUUID_G(uuid, groupId);
328            }
329    
330            /**
331            * Returns all the document library file versions where uuid = &#63; and companyId = &#63;.
332            *
333            * @param uuid the uuid
334            * @param companyId the company ID
335            * @return the matching document library file versions
336            */
337            public static List<DLFileVersion> findByUuid_C(java.lang.String uuid,
338                    long companyId) {
339                    return getPersistence().findByUuid_C(uuid, companyId);
340            }
341    
342            /**
343            * Returns a range of all the document library file versions where uuid = &#63; and companyId = &#63;.
344            *
345            * <p>
346            * 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 DLFileVersionModelImpl}. 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.
347            * </p>
348            *
349            * @param uuid the uuid
350            * @param companyId the company ID
351            * @param start the lower bound of the range of document library file versions
352            * @param end the upper bound of the range of document library file versions (not inclusive)
353            * @return the range of matching document library file versions
354            */
355            public static List<DLFileVersion> findByUuid_C(java.lang.String uuid,
356                    long companyId, int start, int end) {
357                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
358            }
359    
360            /**
361            * Returns an ordered range of all the document library file versions where uuid = &#63; and companyId = &#63;.
362            *
363            * <p>
364            * 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 DLFileVersionModelImpl}. 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.
365            * </p>
366            *
367            * @param uuid the uuid
368            * @param companyId the company ID
369            * @param start the lower bound of the range of document library file versions
370            * @param end the upper bound of the range of document library file versions (not inclusive)
371            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
372            * @return the ordered range of matching document library file versions
373            */
374            public static List<DLFileVersion> findByUuid_C(java.lang.String uuid,
375                    long companyId, int start, int end,
376                    OrderByComparator<DLFileVersion> orderByComparator) {
377                    return getPersistence()
378                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
379            }
380    
381            /**
382            * Returns an ordered range of all the document library file versions where uuid = &#63; and companyId = &#63;.
383            *
384            * <p>
385            * 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 DLFileVersionModelImpl}. 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.
386            * </p>
387            *
388            * @param uuid the uuid
389            * @param companyId the company ID
390            * @param start the lower bound of the range of document library file versions
391            * @param end the upper bound of the range of document library file versions (not inclusive)
392            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
393            * @param retrieveFromCache whether to retrieve from the finder cache
394            * @return the ordered range of matching document library file versions
395            */
396            public static List<DLFileVersion> findByUuid_C(java.lang.String uuid,
397                    long companyId, int start, int end,
398                    OrderByComparator<DLFileVersion> orderByComparator,
399                    boolean retrieveFromCache) {
400                    return getPersistence()
401                                       .findByUuid_C(uuid, companyId, start, end,
402                            orderByComparator, retrieveFromCache);
403            }
404    
405            /**
406            * Returns the first document library file version in the ordered set where uuid = &#63; and companyId = &#63;.
407            *
408            * @param uuid the uuid
409            * @param companyId the company ID
410            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
411            * @return the first matching document library file version
412            * @throws NoSuchFileVersionException if a matching document library file version could not be found
413            */
414            public static DLFileVersion findByUuid_C_First(java.lang.String uuid,
415                    long companyId, OrderByComparator<DLFileVersion> orderByComparator)
416                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
417                    return getPersistence()
418                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
419            }
420    
421            /**
422            * Returns the first document library file version in the ordered set where uuid = &#63; and companyId = &#63;.
423            *
424            * @param uuid the uuid
425            * @param companyId the company ID
426            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
427            * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found
428            */
429            public static DLFileVersion fetchByUuid_C_First(java.lang.String uuid,
430                    long companyId, OrderByComparator<DLFileVersion> orderByComparator) {
431                    return getPersistence()
432                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
433            }
434    
435            /**
436            * Returns the last document library file version in the ordered set where uuid = &#63; and companyId = &#63;.
437            *
438            * @param uuid the uuid
439            * @param companyId the company ID
440            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
441            * @return the last matching document library file version
442            * @throws NoSuchFileVersionException if a matching document library file version could not be found
443            */
444            public static DLFileVersion findByUuid_C_Last(java.lang.String uuid,
445                    long companyId, OrderByComparator<DLFileVersion> orderByComparator)
446                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
447                    return getPersistence()
448                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
449            }
450    
451            /**
452            * Returns the last document library file version in the ordered set where uuid = &#63; and companyId = &#63;.
453            *
454            * @param uuid the uuid
455            * @param companyId the company ID
456            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
457            * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found
458            */
459            public static DLFileVersion fetchByUuid_C_Last(java.lang.String uuid,
460                    long companyId, OrderByComparator<DLFileVersion> orderByComparator) {
461                    return getPersistence()
462                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
463            }
464    
465            /**
466            * Returns the document library file versions before and after the current document library file version in the ordered set where uuid = &#63; and companyId = &#63;.
467            *
468            * @param fileVersionId the primary key of the current document library file version
469            * @param uuid the uuid
470            * @param companyId the company ID
471            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
472            * @return the previous, current, and next document library file version
473            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
474            */
475            public static DLFileVersion[] findByUuid_C_PrevAndNext(long fileVersionId,
476                    java.lang.String uuid, long companyId,
477                    OrderByComparator<DLFileVersion> orderByComparator)
478                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
479                    return getPersistence()
480                                       .findByUuid_C_PrevAndNext(fileVersionId, uuid, companyId,
481                            orderByComparator);
482            }
483    
484            /**
485            * Removes all the document library file versions where uuid = &#63; and companyId = &#63; from the database.
486            *
487            * @param uuid the uuid
488            * @param companyId the company ID
489            */
490            public static void removeByUuid_C(java.lang.String uuid, long companyId) {
491                    getPersistence().removeByUuid_C(uuid, companyId);
492            }
493    
494            /**
495            * Returns the number of document library file versions where uuid = &#63; and companyId = &#63;.
496            *
497            * @param uuid the uuid
498            * @param companyId the company ID
499            * @return the number of matching document library file versions
500            */
501            public static int countByUuid_C(java.lang.String uuid, long companyId) {
502                    return getPersistence().countByUuid_C(uuid, companyId);
503            }
504    
505            /**
506            * Returns all the document library file versions where companyId = &#63;.
507            *
508            * @param companyId the company ID
509            * @return the matching document library file versions
510            */
511            public static List<DLFileVersion> findByCompanyId(long companyId) {
512                    return getPersistence().findByCompanyId(companyId);
513            }
514    
515            /**
516            * Returns a range of all the document library file versions where companyId = &#63;.
517            *
518            * <p>
519            * 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 DLFileVersionModelImpl}. 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.
520            * </p>
521            *
522            * @param companyId the company ID
523            * @param start the lower bound of the range of document library file versions
524            * @param end the upper bound of the range of document library file versions (not inclusive)
525            * @return the range of matching document library file versions
526            */
527            public static List<DLFileVersion> findByCompanyId(long companyId,
528                    int start, int end) {
529                    return getPersistence().findByCompanyId(companyId, start, end);
530            }
531    
532            /**
533            * Returns an ordered range of all the document library file versions where companyId = &#63;.
534            *
535            * <p>
536            * 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 DLFileVersionModelImpl}. 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.
537            * </p>
538            *
539            * @param companyId the company ID
540            * @param start the lower bound of the range of document library file versions
541            * @param end the upper bound of the range of document library file versions (not inclusive)
542            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
543            * @return the ordered range of matching document library file versions
544            */
545            public static List<DLFileVersion> findByCompanyId(long companyId,
546                    int start, int end, OrderByComparator<DLFileVersion> orderByComparator) {
547                    return getPersistence()
548                                       .findByCompanyId(companyId, start, end, orderByComparator);
549            }
550    
551            /**
552            * Returns an ordered range of all the document library file versions where companyId = &#63;.
553            *
554            * <p>
555            * 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 DLFileVersionModelImpl}. 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.
556            * </p>
557            *
558            * @param companyId the company ID
559            * @param start the lower bound of the range of document library file versions
560            * @param end the upper bound of the range of document library file versions (not inclusive)
561            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
562            * @param retrieveFromCache whether to retrieve from the finder cache
563            * @return the ordered range of matching document library file versions
564            */
565            public static List<DLFileVersion> findByCompanyId(long companyId,
566                    int start, int end, OrderByComparator<DLFileVersion> orderByComparator,
567                    boolean retrieveFromCache) {
568                    return getPersistence()
569                                       .findByCompanyId(companyId, start, end, orderByComparator,
570                            retrieveFromCache);
571            }
572    
573            /**
574            * Returns the first document library file version in the ordered set where companyId = &#63;.
575            *
576            * @param companyId the company ID
577            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
578            * @return the first matching document library file version
579            * @throws NoSuchFileVersionException if a matching document library file version could not be found
580            */
581            public static DLFileVersion findByCompanyId_First(long companyId,
582                    OrderByComparator<DLFileVersion> orderByComparator)
583                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
584                    return getPersistence()
585                                       .findByCompanyId_First(companyId, orderByComparator);
586            }
587    
588            /**
589            * Returns the first document library file version in the ordered set where companyId = &#63;.
590            *
591            * @param companyId the company ID
592            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
593            * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found
594            */
595            public static DLFileVersion fetchByCompanyId_First(long companyId,
596                    OrderByComparator<DLFileVersion> orderByComparator) {
597                    return getPersistence()
598                                       .fetchByCompanyId_First(companyId, orderByComparator);
599            }
600    
601            /**
602            * Returns the last document library file version in the ordered set where companyId = &#63;.
603            *
604            * @param companyId the company ID
605            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
606            * @return the last matching document library file version
607            * @throws NoSuchFileVersionException if a matching document library file version could not be found
608            */
609            public static DLFileVersion findByCompanyId_Last(long companyId,
610                    OrderByComparator<DLFileVersion> orderByComparator)
611                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
612                    return getPersistence()
613                                       .findByCompanyId_Last(companyId, orderByComparator);
614            }
615    
616            /**
617            * Returns the last document library file version in the ordered set where companyId = &#63;.
618            *
619            * @param companyId the company ID
620            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
621            * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found
622            */
623            public static DLFileVersion fetchByCompanyId_Last(long companyId,
624                    OrderByComparator<DLFileVersion> orderByComparator) {
625                    return getPersistence()
626                                       .fetchByCompanyId_Last(companyId, orderByComparator);
627            }
628    
629            /**
630            * Returns the document library file versions before and after the current document library file version in the ordered set where companyId = &#63;.
631            *
632            * @param fileVersionId the primary key of the current document library file version
633            * @param companyId the company ID
634            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
635            * @return the previous, current, and next document library file version
636            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
637            */
638            public static DLFileVersion[] findByCompanyId_PrevAndNext(
639                    long fileVersionId, long companyId,
640                    OrderByComparator<DLFileVersion> orderByComparator)
641                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
642                    return getPersistence()
643                                       .findByCompanyId_PrevAndNext(fileVersionId, companyId,
644                            orderByComparator);
645            }
646    
647            /**
648            * Removes all the document library file versions where companyId = &#63; from the database.
649            *
650            * @param companyId the company ID
651            */
652            public static void removeByCompanyId(long companyId) {
653                    getPersistence().removeByCompanyId(companyId);
654            }
655    
656            /**
657            * Returns the number of document library file versions where companyId = &#63;.
658            *
659            * @param companyId the company ID
660            * @return the number of matching document library file versions
661            */
662            public static int countByCompanyId(long companyId) {
663                    return getPersistence().countByCompanyId(companyId);
664            }
665    
666            /**
667            * Returns all the document library file versions where fileEntryId = &#63;.
668            *
669            * @param fileEntryId the file entry ID
670            * @return the matching document library file versions
671            */
672            public static List<DLFileVersion> findByFileEntryId(long fileEntryId) {
673                    return getPersistence().findByFileEntryId(fileEntryId);
674            }
675    
676            /**
677            * Returns a range of all the document library file versions where fileEntryId = &#63;.
678            *
679            * <p>
680            * 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 DLFileVersionModelImpl}. 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.
681            * </p>
682            *
683            * @param fileEntryId the file entry ID
684            * @param start the lower bound of the range of document library file versions
685            * @param end the upper bound of the range of document library file versions (not inclusive)
686            * @return the range of matching document library file versions
687            */
688            public static List<DLFileVersion> findByFileEntryId(long fileEntryId,
689                    int start, int end) {
690                    return getPersistence().findByFileEntryId(fileEntryId, start, end);
691            }
692    
693            /**
694            * Returns an ordered range of all the document library file versions where fileEntryId = &#63;.
695            *
696            * <p>
697            * 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 DLFileVersionModelImpl}. 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.
698            * </p>
699            *
700            * @param fileEntryId the file entry ID
701            * @param start the lower bound of the range of document library file versions
702            * @param end the upper bound of the range of document library file versions (not inclusive)
703            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
704            * @return the ordered range of matching document library file versions
705            */
706            public static List<DLFileVersion> findByFileEntryId(long fileEntryId,
707                    int start, int end, OrderByComparator<DLFileVersion> orderByComparator) {
708                    return getPersistence()
709                                       .findByFileEntryId(fileEntryId, start, end, orderByComparator);
710            }
711    
712            /**
713            * Returns an ordered range of all the document library file versions where fileEntryId = &#63;.
714            *
715            * <p>
716            * 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 DLFileVersionModelImpl}. 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.
717            * </p>
718            *
719            * @param fileEntryId the file entry ID
720            * @param start the lower bound of the range of document library file versions
721            * @param end the upper bound of the range of document library file versions (not inclusive)
722            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
723            * @param retrieveFromCache whether to retrieve from the finder cache
724            * @return the ordered range of matching document library file versions
725            */
726            public static List<DLFileVersion> findByFileEntryId(long fileEntryId,
727                    int start, int end, OrderByComparator<DLFileVersion> orderByComparator,
728                    boolean retrieveFromCache) {
729                    return getPersistence()
730                                       .findByFileEntryId(fileEntryId, start, end,
731                            orderByComparator, retrieveFromCache);
732            }
733    
734            /**
735            * Returns the first document library file version in the ordered set where fileEntryId = &#63;.
736            *
737            * @param fileEntryId the file entry ID
738            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
739            * @return the first matching document library file version
740            * @throws NoSuchFileVersionException if a matching document library file version could not be found
741            */
742            public static DLFileVersion findByFileEntryId_First(long fileEntryId,
743                    OrderByComparator<DLFileVersion> orderByComparator)
744                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
745                    return getPersistence()
746                                       .findByFileEntryId_First(fileEntryId, orderByComparator);
747            }
748    
749            /**
750            * Returns the first document library file version in the ordered set where fileEntryId = &#63;.
751            *
752            * @param fileEntryId the file entry ID
753            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
754            * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found
755            */
756            public static DLFileVersion fetchByFileEntryId_First(long fileEntryId,
757                    OrderByComparator<DLFileVersion> orderByComparator) {
758                    return getPersistence()
759                                       .fetchByFileEntryId_First(fileEntryId, orderByComparator);
760            }
761    
762            /**
763            * Returns the last document library file version in the ordered set where fileEntryId = &#63;.
764            *
765            * @param fileEntryId the file entry ID
766            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
767            * @return the last matching document library file version
768            * @throws NoSuchFileVersionException if a matching document library file version could not be found
769            */
770            public static DLFileVersion findByFileEntryId_Last(long fileEntryId,
771                    OrderByComparator<DLFileVersion> orderByComparator)
772                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
773                    return getPersistence()
774                                       .findByFileEntryId_Last(fileEntryId, orderByComparator);
775            }
776    
777            /**
778            * Returns the last document library file version in the ordered set where fileEntryId = &#63;.
779            *
780            * @param fileEntryId the file entry ID
781            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
782            * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found
783            */
784            public static DLFileVersion fetchByFileEntryId_Last(long fileEntryId,
785                    OrderByComparator<DLFileVersion> orderByComparator) {
786                    return getPersistence()
787                                       .fetchByFileEntryId_Last(fileEntryId, orderByComparator);
788            }
789    
790            /**
791            * Returns the document library file versions before and after the current document library file version in the ordered set where fileEntryId = &#63;.
792            *
793            * @param fileVersionId the primary key of the current document library file version
794            * @param fileEntryId the file entry ID
795            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
796            * @return the previous, current, and next document library file version
797            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
798            */
799            public static DLFileVersion[] findByFileEntryId_PrevAndNext(
800                    long fileVersionId, long fileEntryId,
801                    OrderByComparator<DLFileVersion> orderByComparator)
802                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
803                    return getPersistence()
804                                       .findByFileEntryId_PrevAndNext(fileVersionId, fileEntryId,
805                            orderByComparator);
806            }
807    
808            /**
809            * Removes all the document library file versions where fileEntryId = &#63; from the database.
810            *
811            * @param fileEntryId the file entry ID
812            */
813            public static void removeByFileEntryId(long fileEntryId) {
814                    getPersistence().removeByFileEntryId(fileEntryId);
815            }
816    
817            /**
818            * Returns the number of document library file versions where fileEntryId = &#63;.
819            *
820            * @param fileEntryId the file entry ID
821            * @return the number of matching document library file versions
822            */
823            public static int countByFileEntryId(long fileEntryId) {
824                    return getPersistence().countByFileEntryId(fileEntryId);
825            }
826    
827            /**
828            * Returns all the document library file versions where mimeType = &#63;.
829            *
830            * @param mimeType the mime type
831            * @return the matching document library file versions
832            */
833            public static List<DLFileVersion> findByMimeType(java.lang.String mimeType) {
834                    return getPersistence().findByMimeType(mimeType);
835            }
836    
837            /**
838            * Returns a range of all the document library file versions where mimeType = &#63;.
839            *
840            * <p>
841            * 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 DLFileVersionModelImpl}. 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.
842            * </p>
843            *
844            * @param mimeType the mime type
845            * @param start the lower bound of the range of document library file versions
846            * @param end the upper bound of the range of document library file versions (not inclusive)
847            * @return the range of matching document library file versions
848            */
849            public static List<DLFileVersion> findByMimeType(
850                    java.lang.String mimeType, int start, int end) {
851                    return getPersistence().findByMimeType(mimeType, start, end);
852            }
853    
854            /**
855            * Returns an ordered range of all the document library file versions where mimeType = &#63;.
856            *
857            * <p>
858            * 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 DLFileVersionModelImpl}. 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.
859            * </p>
860            *
861            * @param mimeType the mime type
862            * @param start the lower bound of the range of document library file versions
863            * @param end the upper bound of the range of document library file versions (not inclusive)
864            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
865            * @return the ordered range of matching document library file versions
866            */
867            public static List<DLFileVersion> findByMimeType(
868                    java.lang.String mimeType, int start, int end,
869                    OrderByComparator<DLFileVersion> orderByComparator) {
870                    return getPersistence()
871                                       .findByMimeType(mimeType, start, end, orderByComparator);
872            }
873    
874            /**
875            * Returns an ordered range of all the document library file versions where mimeType = &#63;.
876            *
877            * <p>
878            * 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 DLFileVersionModelImpl}. 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.
879            * </p>
880            *
881            * @param mimeType the mime type
882            * @param start the lower bound of the range of document library file versions
883            * @param end the upper bound of the range of document library file versions (not inclusive)
884            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
885            * @param retrieveFromCache whether to retrieve from the finder cache
886            * @return the ordered range of matching document library file versions
887            */
888            public static List<DLFileVersion> findByMimeType(
889                    java.lang.String mimeType, int start, int end,
890                    OrderByComparator<DLFileVersion> orderByComparator,
891                    boolean retrieveFromCache) {
892                    return getPersistence()
893                                       .findByMimeType(mimeType, start, end, orderByComparator,
894                            retrieveFromCache);
895            }
896    
897            /**
898            * Returns the first document library file version in the ordered set where mimeType = &#63;.
899            *
900            * @param mimeType the mime type
901            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
902            * @return the first matching document library file version
903            * @throws NoSuchFileVersionException if a matching document library file version could not be found
904            */
905            public static DLFileVersion findByMimeType_First(
906                    java.lang.String mimeType,
907                    OrderByComparator<DLFileVersion> orderByComparator)
908                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
909                    return getPersistence().findByMimeType_First(mimeType, orderByComparator);
910            }
911    
912            /**
913            * Returns the first document library file version in the ordered set where mimeType = &#63;.
914            *
915            * @param mimeType the mime type
916            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
917            * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found
918            */
919            public static DLFileVersion fetchByMimeType_First(
920                    java.lang.String mimeType,
921                    OrderByComparator<DLFileVersion> orderByComparator) {
922                    return getPersistence()
923                                       .fetchByMimeType_First(mimeType, orderByComparator);
924            }
925    
926            /**
927            * Returns the last document library file version in the ordered set where mimeType = &#63;.
928            *
929            * @param mimeType the mime type
930            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
931            * @return the last matching document library file version
932            * @throws NoSuchFileVersionException if a matching document library file version could not be found
933            */
934            public static DLFileVersion findByMimeType_Last(java.lang.String mimeType,
935                    OrderByComparator<DLFileVersion> orderByComparator)
936                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
937                    return getPersistence().findByMimeType_Last(mimeType, orderByComparator);
938            }
939    
940            /**
941            * Returns the last document library file version in the ordered set where mimeType = &#63;.
942            *
943            * @param mimeType the mime type
944            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
945            * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found
946            */
947            public static DLFileVersion fetchByMimeType_Last(
948                    java.lang.String mimeType,
949                    OrderByComparator<DLFileVersion> orderByComparator) {
950                    return getPersistence().fetchByMimeType_Last(mimeType, orderByComparator);
951            }
952    
953            /**
954            * Returns the document library file versions before and after the current document library file version in the ordered set where mimeType = &#63;.
955            *
956            * @param fileVersionId the primary key of the current document library file version
957            * @param mimeType the mime type
958            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
959            * @return the previous, current, and next document library file version
960            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
961            */
962            public static DLFileVersion[] findByMimeType_PrevAndNext(
963                    long fileVersionId, java.lang.String mimeType,
964                    OrderByComparator<DLFileVersion> orderByComparator)
965                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
966                    return getPersistence()
967                                       .findByMimeType_PrevAndNext(fileVersionId, mimeType,
968                            orderByComparator);
969            }
970    
971            /**
972            * Removes all the document library file versions where mimeType = &#63; from the database.
973            *
974            * @param mimeType the mime type
975            */
976            public static void removeByMimeType(java.lang.String mimeType) {
977                    getPersistence().removeByMimeType(mimeType);
978            }
979    
980            /**
981            * Returns the number of document library file versions where mimeType = &#63;.
982            *
983            * @param mimeType the mime type
984            * @return the number of matching document library file versions
985            */
986            public static int countByMimeType(java.lang.String mimeType) {
987                    return getPersistence().countByMimeType(mimeType);
988            }
989    
990            /**
991            * Returns all the document library file versions where companyId = &#63; and status &ne; &#63;.
992            *
993            * @param companyId the company ID
994            * @param status the status
995            * @return the matching document library file versions
996            */
997            public static List<DLFileVersion> findByC_NotS(long companyId, int status) {
998                    return getPersistence().findByC_NotS(companyId, status);
999            }
1000    
1001            /**
1002            * Returns a range of all the document library file versions where companyId = &#63; and status &ne; &#63;.
1003            *
1004            * <p>
1005            * 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 DLFileVersionModelImpl}. 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.
1006            * </p>
1007            *
1008            * @param companyId the company ID
1009            * @param status the status
1010            * @param start the lower bound of the range of document library file versions
1011            * @param end the upper bound of the range of document library file versions (not inclusive)
1012            * @return the range of matching document library file versions
1013            */
1014            public static List<DLFileVersion> findByC_NotS(long companyId, int status,
1015                    int start, int end) {
1016                    return getPersistence().findByC_NotS(companyId, status, start, end);
1017            }
1018    
1019            /**
1020            * Returns an ordered range of all the document library file versions where companyId = &#63; and status &ne; &#63;.
1021            *
1022            * <p>
1023            * 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 DLFileVersionModelImpl}. 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.
1024            * </p>
1025            *
1026            * @param companyId the company ID
1027            * @param status the status
1028            * @param start the lower bound of the range of document library file versions
1029            * @param end the upper bound of the range of document library file versions (not inclusive)
1030            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1031            * @return the ordered range of matching document library file versions
1032            */
1033            public static List<DLFileVersion> findByC_NotS(long companyId, int status,
1034                    int start, int end, OrderByComparator<DLFileVersion> orderByComparator) {
1035                    return getPersistence()
1036                                       .findByC_NotS(companyId, status, start, end,
1037                            orderByComparator);
1038            }
1039    
1040            /**
1041            * Returns an ordered range of all the document library file versions where companyId = &#63; and status &ne; &#63;.
1042            *
1043            * <p>
1044            * 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 DLFileVersionModelImpl}. 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.
1045            * </p>
1046            *
1047            * @param companyId the company ID
1048            * @param status the status
1049            * @param start the lower bound of the range of document library file versions
1050            * @param end the upper bound of the range of document library file versions (not inclusive)
1051            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1052            * @param retrieveFromCache whether to retrieve from the finder cache
1053            * @return the ordered range of matching document library file versions
1054            */
1055            public static List<DLFileVersion> findByC_NotS(long companyId, int status,
1056                    int start, int end, OrderByComparator<DLFileVersion> orderByComparator,
1057                    boolean retrieveFromCache) {
1058                    return getPersistence()
1059                                       .findByC_NotS(companyId, status, start, end,
1060                            orderByComparator, retrieveFromCache);
1061            }
1062    
1063            /**
1064            * Returns the first document library file version in the ordered set where companyId = &#63; and status &ne; &#63;.
1065            *
1066            * @param companyId the company ID
1067            * @param status the status
1068            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1069            * @return the first matching document library file version
1070            * @throws NoSuchFileVersionException if a matching document library file version could not be found
1071            */
1072            public static DLFileVersion findByC_NotS_First(long companyId, int status,
1073                    OrderByComparator<DLFileVersion> orderByComparator)
1074                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
1075                    return getPersistence()
1076                                       .findByC_NotS_First(companyId, status, orderByComparator);
1077            }
1078    
1079            /**
1080            * Returns the first document library file version in the ordered set where companyId = &#63; and status &ne; &#63;.
1081            *
1082            * @param companyId the company ID
1083            * @param status the status
1084            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1085            * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found
1086            */
1087            public static DLFileVersion fetchByC_NotS_First(long companyId, int status,
1088                    OrderByComparator<DLFileVersion> orderByComparator) {
1089                    return getPersistence()
1090                                       .fetchByC_NotS_First(companyId, status, orderByComparator);
1091            }
1092    
1093            /**
1094            * Returns the last document library file version in the ordered set where companyId = &#63; and status &ne; &#63;.
1095            *
1096            * @param companyId the company ID
1097            * @param status the status
1098            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1099            * @return the last matching document library file version
1100            * @throws NoSuchFileVersionException if a matching document library file version could not be found
1101            */
1102            public static DLFileVersion findByC_NotS_Last(long companyId, int status,
1103                    OrderByComparator<DLFileVersion> orderByComparator)
1104                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
1105                    return getPersistence()
1106                                       .findByC_NotS_Last(companyId, status, orderByComparator);
1107            }
1108    
1109            /**
1110            * Returns the last document library file version in the ordered set where companyId = &#63; and status &ne; &#63;.
1111            *
1112            * @param companyId the company ID
1113            * @param status the status
1114            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1115            * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found
1116            */
1117            public static DLFileVersion fetchByC_NotS_Last(long companyId, int status,
1118                    OrderByComparator<DLFileVersion> orderByComparator) {
1119                    return getPersistence()
1120                                       .fetchByC_NotS_Last(companyId, status, orderByComparator);
1121            }
1122    
1123            /**
1124            * Returns the document library file versions before and after the current document library file version in the ordered set where companyId = &#63; and status &ne; &#63;.
1125            *
1126            * @param fileVersionId the primary key of the current document library file version
1127            * @param companyId the company ID
1128            * @param status the status
1129            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1130            * @return the previous, current, and next document library file version
1131            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
1132            */
1133            public static DLFileVersion[] findByC_NotS_PrevAndNext(long fileVersionId,
1134                    long companyId, int status,
1135                    OrderByComparator<DLFileVersion> orderByComparator)
1136                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
1137                    return getPersistence()
1138                                       .findByC_NotS_PrevAndNext(fileVersionId, companyId, status,
1139                            orderByComparator);
1140            }
1141    
1142            /**
1143            * Removes all the document library file versions where companyId = &#63; and status &ne; &#63; from the database.
1144            *
1145            * @param companyId the company ID
1146            * @param status the status
1147            */
1148            public static void removeByC_NotS(long companyId, int status) {
1149                    getPersistence().removeByC_NotS(companyId, status);
1150            }
1151    
1152            /**
1153            * Returns the number of document library file versions where companyId = &#63; and status &ne; &#63;.
1154            *
1155            * @param companyId the company ID
1156            * @param status the status
1157            * @return the number of matching document library file versions
1158            */
1159            public static int countByC_NotS(long companyId, int status) {
1160                    return getPersistence().countByC_NotS(companyId, status);
1161            }
1162    
1163            /**
1164            * Returns the document library file version where fileEntryId = &#63; and version = &#63; or throws a {@link NoSuchFileVersionException} if it could not be found.
1165            *
1166            * @param fileEntryId the file entry ID
1167            * @param version the version
1168            * @return the matching document library file version
1169            * @throws NoSuchFileVersionException if a matching document library file version could not be found
1170            */
1171            public static DLFileVersion findByF_V(long fileEntryId,
1172                    java.lang.String version)
1173                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
1174                    return getPersistence().findByF_V(fileEntryId, version);
1175            }
1176    
1177            /**
1178            * Returns the document library file version where fileEntryId = &#63; and version = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1179            *
1180            * @param fileEntryId the file entry ID
1181            * @param version the version
1182            * @return the matching document library file version, or <code>null</code> if a matching document library file version could not be found
1183            */
1184            public static DLFileVersion fetchByF_V(long fileEntryId,
1185                    java.lang.String version) {
1186                    return getPersistence().fetchByF_V(fileEntryId, version);
1187            }
1188    
1189            /**
1190            * Returns the document library file version where fileEntryId = &#63; and version = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1191            *
1192            * @param fileEntryId the file entry ID
1193            * @param version the version
1194            * @param retrieveFromCache whether to retrieve from the finder cache
1195            * @return the matching document library file version, or <code>null</code> if a matching document library file version could not be found
1196            */
1197            public static DLFileVersion fetchByF_V(long fileEntryId,
1198                    java.lang.String version, boolean retrieveFromCache) {
1199                    return getPersistence()
1200                                       .fetchByF_V(fileEntryId, version, retrieveFromCache);
1201            }
1202    
1203            /**
1204            * Removes the document library file version where fileEntryId = &#63; and version = &#63; from the database.
1205            *
1206            * @param fileEntryId the file entry ID
1207            * @param version the version
1208            * @return the document library file version that was removed
1209            */
1210            public static DLFileVersion removeByF_V(long fileEntryId,
1211                    java.lang.String version)
1212                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
1213                    return getPersistence().removeByF_V(fileEntryId, version);
1214            }
1215    
1216            /**
1217            * Returns the number of document library file versions where fileEntryId = &#63; and version = &#63;.
1218            *
1219            * @param fileEntryId the file entry ID
1220            * @param version the version
1221            * @return the number of matching document library file versions
1222            */
1223            public static int countByF_V(long fileEntryId, java.lang.String version) {
1224                    return getPersistence().countByF_V(fileEntryId, version);
1225            }
1226    
1227            /**
1228            * Returns all the document library file versions where fileEntryId = &#63; and status = &#63;.
1229            *
1230            * @param fileEntryId the file entry ID
1231            * @param status the status
1232            * @return the matching document library file versions
1233            */
1234            public static List<DLFileVersion> findByF_S(long fileEntryId, int status) {
1235                    return getPersistence().findByF_S(fileEntryId, status);
1236            }
1237    
1238            /**
1239            * Returns a range of all the document library file versions where fileEntryId = &#63; and status = &#63;.
1240            *
1241            * <p>
1242            * 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 DLFileVersionModelImpl}. 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.
1243            * </p>
1244            *
1245            * @param fileEntryId the file entry ID
1246            * @param status the status
1247            * @param start the lower bound of the range of document library file versions
1248            * @param end the upper bound of the range of document library file versions (not inclusive)
1249            * @return the range of matching document library file versions
1250            */
1251            public static List<DLFileVersion> findByF_S(long fileEntryId, int status,
1252                    int start, int end) {
1253                    return getPersistence().findByF_S(fileEntryId, status, start, end);
1254            }
1255    
1256            /**
1257            * Returns an ordered range of all the document library file versions where fileEntryId = &#63; and status = &#63;.
1258            *
1259            * <p>
1260            * 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 DLFileVersionModelImpl}. 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.
1261            * </p>
1262            *
1263            * @param fileEntryId the file entry ID
1264            * @param status the status
1265            * @param start the lower bound of the range of document library file versions
1266            * @param end the upper bound of the range of document library file versions (not inclusive)
1267            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1268            * @return the ordered range of matching document library file versions
1269            */
1270            public static List<DLFileVersion> findByF_S(long fileEntryId, int status,
1271                    int start, int end, OrderByComparator<DLFileVersion> orderByComparator) {
1272                    return getPersistence()
1273                                       .findByF_S(fileEntryId, status, start, end, orderByComparator);
1274            }
1275    
1276            /**
1277            * Returns an ordered range of all the document library file versions where fileEntryId = &#63; and status = &#63;.
1278            *
1279            * <p>
1280            * 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 DLFileVersionModelImpl}. 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.
1281            * </p>
1282            *
1283            * @param fileEntryId the file entry ID
1284            * @param status the status
1285            * @param start the lower bound of the range of document library file versions
1286            * @param end the upper bound of the range of document library file versions (not inclusive)
1287            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1288            * @param retrieveFromCache whether to retrieve from the finder cache
1289            * @return the ordered range of matching document library file versions
1290            */
1291            public static List<DLFileVersion> findByF_S(long fileEntryId, int status,
1292                    int start, int end, OrderByComparator<DLFileVersion> orderByComparator,
1293                    boolean retrieveFromCache) {
1294                    return getPersistence()
1295                                       .findByF_S(fileEntryId, status, start, end,
1296                            orderByComparator, retrieveFromCache);
1297            }
1298    
1299            /**
1300            * Returns the first document library file version in the ordered set where fileEntryId = &#63; and status = &#63;.
1301            *
1302            * @param fileEntryId the file entry ID
1303            * @param status the status
1304            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1305            * @return the first matching document library file version
1306            * @throws NoSuchFileVersionException if a matching document library file version could not be found
1307            */
1308            public static DLFileVersion findByF_S_First(long fileEntryId, int status,
1309                    OrderByComparator<DLFileVersion> orderByComparator)
1310                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
1311                    return getPersistence()
1312                                       .findByF_S_First(fileEntryId, status, orderByComparator);
1313            }
1314    
1315            /**
1316            * Returns the first document library file version in the ordered set where fileEntryId = &#63; and status = &#63;.
1317            *
1318            * @param fileEntryId the file entry ID
1319            * @param status the status
1320            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1321            * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found
1322            */
1323            public static DLFileVersion fetchByF_S_First(long fileEntryId, int status,
1324                    OrderByComparator<DLFileVersion> orderByComparator) {
1325                    return getPersistence()
1326                                       .fetchByF_S_First(fileEntryId, status, orderByComparator);
1327            }
1328    
1329            /**
1330            * Returns the last document library file version in the ordered set where fileEntryId = &#63; and status = &#63;.
1331            *
1332            * @param fileEntryId the file entry ID
1333            * @param status the status
1334            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1335            * @return the last matching document library file version
1336            * @throws NoSuchFileVersionException if a matching document library file version could not be found
1337            */
1338            public static DLFileVersion findByF_S_Last(long fileEntryId, int status,
1339                    OrderByComparator<DLFileVersion> orderByComparator)
1340                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
1341                    return getPersistence()
1342                                       .findByF_S_Last(fileEntryId, status, orderByComparator);
1343            }
1344    
1345            /**
1346            * Returns the last document library file version in the ordered set where fileEntryId = &#63; and status = &#63;.
1347            *
1348            * @param fileEntryId the file entry ID
1349            * @param status the status
1350            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1351            * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found
1352            */
1353            public static DLFileVersion fetchByF_S_Last(long fileEntryId, int status,
1354                    OrderByComparator<DLFileVersion> orderByComparator) {
1355                    return getPersistence()
1356                                       .fetchByF_S_Last(fileEntryId, status, orderByComparator);
1357            }
1358    
1359            /**
1360            * Returns the document library file versions before and after the current document library file version in the ordered set where fileEntryId = &#63; and status = &#63;.
1361            *
1362            * @param fileVersionId the primary key of the current document library file version
1363            * @param fileEntryId the file entry ID
1364            * @param status the status
1365            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1366            * @return the previous, current, and next document library file version
1367            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
1368            */
1369            public static DLFileVersion[] findByF_S_PrevAndNext(long fileVersionId,
1370                    long fileEntryId, int status,
1371                    OrderByComparator<DLFileVersion> orderByComparator)
1372                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
1373                    return getPersistence()
1374                                       .findByF_S_PrevAndNext(fileVersionId, fileEntryId, status,
1375                            orderByComparator);
1376            }
1377    
1378            /**
1379            * Removes all the document library file versions where fileEntryId = &#63; and status = &#63; from the database.
1380            *
1381            * @param fileEntryId the file entry ID
1382            * @param status the status
1383            */
1384            public static void removeByF_S(long fileEntryId, int status) {
1385                    getPersistence().removeByF_S(fileEntryId, status);
1386            }
1387    
1388            /**
1389            * Returns the number of document library file versions where fileEntryId = &#63; and status = &#63;.
1390            *
1391            * @param fileEntryId the file entry ID
1392            * @param status the status
1393            * @return the number of matching document library file versions
1394            */
1395            public static int countByF_S(long fileEntryId, int status) {
1396                    return getPersistence().countByF_S(fileEntryId, status);
1397            }
1398    
1399            /**
1400            * Returns all the document library file versions where groupId = &#63; and folderId = &#63; and status = &#63;.
1401            *
1402            * @param groupId the group ID
1403            * @param folderId the folder ID
1404            * @param status the status
1405            * @return the matching document library file versions
1406            */
1407            public static List<DLFileVersion> findByG_F_S(long groupId, long folderId,
1408                    int status) {
1409                    return getPersistence().findByG_F_S(groupId, folderId, status);
1410            }
1411    
1412            /**
1413            * Returns a range of all the document library file versions where groupId = &#63; and folderId = &#63; and status = &#63;.
1414            *
1415            * <p>
1416            * 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 DLFileVersionModelImpl}. 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.
1417            * </p>
1418            *
1419            * @param groupId the group ID
1420            * @param folderId the folder ID
1421            * @param status the status
1422            * @param start the lower bound of the range of document library file versions
1423            * @param end the upper bound of the range of document library file versions (not inclusive)
1424            * @return the range of matching document library file versions
1425            */
1426            public static List<DLFileVersion> findByG_F_S(long groupId, long folderId,
1427                    int status, int start, int end) {
1428                    return getPersistence()
1429                                       .findByG_F_S(groupId, folderId, status, start, end);
1430            }
1431    
1432            /**
1433            * Returns an ordered range of all the document library file versions where groupId = &#63; and folderId = &#63; and status = &#63;.
1434            *
1435            * <p>
1436            * 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 DLFileVersionModelImpl}. 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.
1437            * </p>
1438            *
1439            * @param groupId the group ID
1440            * @param folderId the folder ID
1441            * @param status the status
1442            * @param start the lower bound of the range of document library file versions
1443            * @param end the upper bound of the range of document library file versions (not inclusive)
1444            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1445            * @return the ordered range of matching document library file versions
1446            */
1447            public static List<DLFileVersion> findByG_F_S(long groupId, long folderId,
1448                    int status, int start, int end,
1449                    OrderByComparator<DLFileVersion> orderByComparator) {
1450                    return getPersistence()
1451                                       .findByG_F_S(groupId, folderId, status, start, end,
1452                            orderByComparator);
1453            }
1454    
1455            /**
1456            * Returns an ordered range of all the document library file versions where groupId = &#63; and folderId = &#63; and status = &#63;.
1457            *
1458            * <p>
1459            * 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 DLFileVersionModelImpl}. 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.
1460            * </p>
1461            *
1462            * @param groupId the group ID
1463            * @param folderId the folder ID
1464            * @param status the status
1465            * @param start the lower bound of the range of document library file versions
1466            * @param end the upper bound of the range of document library file versions (not inclusive)
1467            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1468            * @param retrieveFromCache whether to retrieve from the finder cache
1469            * @return the ordered range of matching document library file versions
1470            */
1471            public static List<DLFileVersion> findByG_F_S(long groupId, long folderId,
1472                    int status, int start, int end,
1473                    OrderByComparator<DLFileVersion> orderByComparator,
1474                    boolean retrieveFromCache) {
1475                    return getPersistence()
1476                                       .findByG_F_S(groupId, folderId, status, start, end,
1477                            orderByComparator, retrieveFromCache);
1478            }
1479    
1480            /**
1481            * Returns the first document library file version in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
1482            *
1483            * @param groupId the group ID
1484            * @param folderId the folder ID
1485            * @param status the status
1486            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1487            * @return the first matching document library file version
1488            * @throws NoSuchFileVersionException if a matching document library file version could not be found
1489            */
1490            public static DLFileVersion findByG_F_S_First(long groupId, long folderId,
1491                    int status, OrderByComparator<DLFileVersion> orderByComparator)
1492                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
1493                    return getPersistence()
1494                                       .findByG_F_S_First(groupId, folderId, status,
1495                            orderByComparator);
1496            }
1497    
1498            /**
1499            * Returns the first document library file version in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
1500            *
1501            * @param groupId the group ID
1502            * @param folderId the folder ID
1503            * @param status the status
1504            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1505            * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found
1506            */
1507            public static DLFileVersion fetchByG_F_S_First(long groupId, long folderId,
1508                    int status, OrderByComparator<DLFileVersion> orderByComparator) {
1509                    return getPersistence()
1510                                       .fetchByG_F_S_First(groupId, folderId, status,
1511                            orderByComparator);
1512            }
1513    
1514            /**
1515            * Returns the last document library file version in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
1516            *
1517            * @param groupId the group ID
1518            * @param folderId the folder ID
1519            * @param status the status
1520            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1521            * @return the last matching document library file version
1522            * @throws NoSuchFileVersionException if a matching document library file version could not be found
1523            */
1524            public static DLFileVersion findByG_F_S_Last(long groupId, long folderId,
1525                    int status, OrderByComparator<DLFileVersion> orderByComparator)
1526                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
1527                    return getPersistence()
1528                                       .findByG_F_S_Last(groupId, folderId, status,
1529                            orderByComparator);
1530            }
1531    
1532            /**
1533            * Returns the last document library file version in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
1534            *
1535            * @param groupId the group ID
1536            * @param folderId the folder ID
1537            * @param status the status
1538            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1539            * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found
1540            */
1541            public static DLFileVersion fetchByG_F_S_Last(long groupId, long folderId,
1542                    int status, OrderByComparator<DLFileVersion> orderByComparator) {
1543                    return getPersistence()
1544                                       .fetchByG_F_S_Last(groupId, folderId, status,
1545                            orderByComparator);
1546            }
1547    
1548            /**
1549            * Returns the document library file versions before and after the current document library file version in the ordered set where groupId = &#63; and folderId = &#63; and status = &#63;.
1550            *
1551            * @param fileVersionId the primary key of the current document library file version
1552            * @param groupId the group ID
1553            * @param folderId the folder ID
1554            * @param status the status
1555            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1556            * @return the previous, current, and next document library file version
1557            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
1558            */
1559            public static DLFileVersion[] findByG_F_S_PrevAndNext(long fileVersionId,
1560                    long groupId, long folderId, int status,
1561                    OrderByComparator<DLFileVersion> orderByComparator)
1562                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
1563                    return getPersistence()
1564                                       .findByG_F_S_PrevAndNext(fileVersionId, groupId, folderId,
1565                            status, orderByComparator);
1566            }
1567    
1568            /**
1569            * Removes all the document library file versions where groupId = &#63; and folderId = &#63; and status = &#63; from the database.
1570            *
1571            * @param groupId the group ID
1572            * @param folderId the folder ID
1573            * @param status the status
1574            */
1575            public static void removeByG_F_S(long groupId, long folderId, int status) {
1576                    getPersistence().removeByG_F_S(groupId, folderId, status);
1577            }
1578    
1579            /**
1580            * Returns the number of document library file versions where groupId = &#63; and folderId = &#63; and status = &#63;.
1581            *
1582            * @param groupId the group ID
1583            * @param folderId the folder ID
1584            * @param status the status
1585            * @return the number of matching document library file versions
1586            */
1587            public static int countByG_F_S(long groupId, long folderId, int status) {
1588                    return getPersistence().countByG_F_S(groupId, folderId, status);
1589            }
1590    
1591            /**
1592            * Returns all the document library file versions where groupId = &#63; and folderId = &#63; and title = &#63; and version = &#63;.
1593            *
1594            * @param groupId the group ID
1595            * @param folderId the folder ID
1596            * @param title the title
1597            * @param version the version
1598            * @return the matching document library file versions
1599            */
1600            public static List<DLFileVersion> findByG_F_T_V(long groupId,
1601                    long folderId, java.lang.String title, java.lang.String version) {
1602                    return getPersistence().findByG_F_T_V(groupId, folderId, title, version);
1603            }
1604    
1605            /**
1606            * Returns a range of all the document library file versions where groupId = &#63; and folderId = &#63; and title = &#63; and version = &#63;.
1607            *
1608            * <p>
1609            * 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 DLFileVersionModelImpl}. 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.
1610            * </p>
1611            *
1612            * @param groupId the group ID
1613            * @param folderId the folder ID
1614            * @param title the title
1615            * @param version the version
1616            * @param start the lower bound of the range of document library file versions
1617            * @param end the upper bound of the range of document library file versions (not inclusive)
1618            * @return the range of matching document library file versions
1619            */
1620            public static List<DLFileVersion> findByG_F_T_V(long groupId,
1621                    long folderId, java.lang.String title, java.lang.String version,
1622                    int start, int end) {
1623                    return getPersistence()
1624                                       .findByG_F_T_V(groupId, folderId, title, version, start, end);
1625            }
1626    
1627            /**
1628            * Returns an ordered range of all the document library file versions where groupId = &#63; and folderId = &#63; and title = &#63; and version = &#63;.
1629            *
1630            * <p>
1631            * 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 DLFileVersionModelImpl}. 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.
1632            * </p>
1633            *
1634            * @param groupId the group ID
1635            * @param folderId the folder ID
1636            * @param title the title
1637            * @param version the version
1638            * @param start the lower bound of the range of document library file versions
1639            * @param end the upper bound of the range of document library file versions (not inclusive)
1640            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1641            * @return the ordered range of matching document library file versions
1642            */
1643            public static List<DLFileVersion> findByG_F_T_V(long groupId,
1644                    long folderId, java.lang.String title, java.lang.String version,
1645                    int start, int end, OrderByComparator<DLFileVersion> orderByComparator) {
1646                    return getPersistence()
1647                                       .findByG_F_T_V(groupId, folderId, title, version, start,
1648                            end, orderByComparator);
1649            }
1650    
1651            /**
1652            * Returns an ordered range of all the document library file versions where groupId = &#63; and folderId = &#63; and title = &#63; and version = &#63;.
1653            *
1654            * <p>
1655            * 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 DLFileVersionModelImpl}. 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.
1656            * </p>
1657            *
1658            * @param groupId the group ID
1659            * @param folderId the folder ID
1660            * @param title the title
1661            * @param version the version
1662            * @param start the lower bound of the range of document library file versions
1663            * @param end the upper bound of the range of document library file versions (not inclusive)
1664            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1665            * @param retrieveFromCache whether to retrieve from the finder cache
1666            * @return the ordered range of matching document library file versions
1667            */
1668            public static List<DLFileVersion> findByG_F_T_V(long groupId,
1669                    long folderId, java.lang.String title, java.lang.String version,
1670                    int start, int end, OrderByComparator<DLFileVersion> orderByComparator,
1671                    boolean retrieveFromCache) {
1672                    return getPersistence()
1673                                       .findByG_F_T_V(groupId, folderId, title, version, start,
1674                            end, orderByComparator, retrieveFromCache);
1675            }
1676    
1677            /**
1678            * Returns the first document library file version in the ordered set where groupId = &#63; and folderId = &#63; and title = &#63; and version = &#63;.
1679            *
1680            * @param groupId the group ID
1681            * @param folderId the folder ID
1682            * @param title the title
1683            * @param version the version
1684            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1685            * @return the first matching document library file version
1686            * @throws NoSuchFileVersionException if a matching document library file version could not be found
1687            */
1688            public static DLFileVersion findByG_F_T_V_First(long groupId,
1689                    long folderId, java.lang.String title, java.lang.String version,
1690                    OrderByComparator<DLFileVersion> orderByComparator)
1691                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
1692                    return getPersistence()
1693                                       .findByG_F_T_V_First(groupId, folderId, title, version,
1694                            orderByComparator);
1695            }
1696    
1697            /**
1698            * Returns the first document library file version in the ordered set where groupId = &#63; and folderId = &#63; and title = &#63; and version = &#63;.
1699            *
1700            * @param groupId the group ID
1701            * @param folderId the folder ID
1702            * @param title the title
1703            * @param version the version
1704            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1705            * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found
1706            */
1707            public static DLFileVersion fetchByG_F_T_V_First(long groupId,
1708                    long folderId, java.lang.String title, java.lang.String version,
1709                    OrderByComparator<DLFileVersion> orderByComparator) {
1710                    return getPersistence()
1711                                       .fetchByG_F_T_V_First(groupId, folderId, title, version,
1712                            orderByComparator);
1713            }
1714    
1715            /**
1716            * Returns the last document library file version in the ordered set where groupId = &#63; and folderId = &#63; and title = &#63; and version = &#63;.
1717            *
1718            * @param groupId the group ID
1719            * @param folderId the folder ID
1720            * @param title the title
1721            * @param version the version
1722            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1723            * @return the last matching document library file version
1724            * @throws NoSuchFileVersionException if a matching document library file version could not be found
1725            */
1726            public static DLFileVersion findByG_F_T_V_Last(long groupId, long folderId,
1727                    java.lang.String title, java.lang.String version,
1728                    OrderByComparator<DLFileVersion> orderByComparator)
1729                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
1730                    return getPersistence()
1731                                       .findByG_F_T_V_Last(groupId, folderId, title, version,
1732                            orderByComparator);
1733            }
1734    
1735            /**
1736            * Returns the last document library file version in the ordered set where groupId = &#63; and folderId = &#63; and title = &#63; and version = &#63;.
1737            *
1738            * @param groupId the group ID
1739            * @param folderId the folder ID
1740            * @param title the title
1741            * @param version the version
1742            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1743            * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found
1744            */
1745            public static DLFileVersion fetchByG_F_T_V_Last(long groupId,
1746                    long folderId, java.lang.String title, java.lang.String version,
1747                    OrderByComparator<DLFileVersion> orderByComparator) {
1748                    return getPersistence()
1749                                       .fetchByG_F_T_V_Last(groupId, folderId, title, version,
1750                            orderByComparator);
1751            }
1752    
1753            /**
1754            * Returns the document library file versions before and after the current document library file version in the ordered set where groupId = &#63; and folderId = &#63; and title = &#63; and version = &#63;.
1755            *
1756            * @param fileVersionId the primary key of the current document library file version
1757            * @param groupId the group ID
1758            * @param folderId the folder ID
1759            * @param title the title
1760            * @param version the version
1761            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1762            * @return the previous, current, and next document library file version
1763            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
1764            */
1765            public static DLFileVersion[] findByG_F_T_V_PrevAndNext(
1766                    long fileVersionId, long groupId, long folderId,
1767                    java.lang.String title, java.lang.String version,
1768                    OrderByComparator<DLFileVersion> orderByComparator)
1769                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
1770                    return getPersistence()
1771                                       .findByG_F_T_V_PrevAndNext(fileVersionId, groupId, folderId,
1772                            title, version, orderByComparator);
1773            }
1774    
1775            /**
1776            * Removes all the document library file versions where groupId = &#63; and folderId = &#63; and title = &#63; and version = &#63; from the database.
1777            *
1778            * @param groupId the group ID
1779            * @param folderId the folder ID
1780            * @param title the title
1781            * @param version the version
1782            */
1783            public static void removeByG_F_T_V(long groupId, long folderId,
1784                    java.lang.String title, java.lang.String version) {
1785                    getPersistence().removeByG_F_T_V(groupId, folderId, title, version);
1786            }
1787    
1788            /**
1789            * Returns the number of document library file versions where groupId = &#63; and folderId = &#63; and title = &#63; and version = &#63;.
1790            *
1791            * @param groupId the group ID
1792            * @param folderId the folder ID
1793            * @param title the title
1794            * @param version the version
1795            * @return the number of matching document library file versions
1796            */
1797            public static int countByG_F_T_V(long groupId, long folderId,
1798                    java.lang.String title, java.lang.String version) {
1799                    return getPersistence().countByG_F_T_V(groupId, folderId, title, version);
1800            }
1801    
1802            /**
1803            * Caches the document library file version in the entity cache if it is enabled.
1804            *
1805            * @param dlFileVersion the document library file version
1806            */
1807            public static void cacheResult(DLFileVersion dlFileVersion) {
1808                    getPersistence().cacheResult(dlFileVersion);
1809            }
1810    
1811            /**
1812            * Caches the document library file versions in the entity cache if it is enabled.
1813            *
1814            * @param dlFileVersions the document library file versions
1815            */
1816            public static void cacheResult(List<DLFileVersion> dlFileVersions) {
1817                    getPersistence().cacheResult(dlFileVersions);
1818            }
1819    
1820            /**
1821            * Creates a new document library file version with the primary key. Does not add the document library file version to the database.
1822            *
1823            * @param fileVersionId the primary key for the new document library file version
1824            * @return the new document library file version
1825            */
1826            public static DLFileVersion create(long fileVersionId) {
1827                    return getPersistence().create(fileVersionId);
1828            }
1829    
1830            /**
1831            * Removes the document library file version with the primary key from the database. Also notifies the appropriate model listeners.
1832            *
1833            * @param fileVersionId the primary key of the document library file version
1834            * @return the document library file version that was removed
1835            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
1836            */
1837            public static DLFileVersion remove(long fileVersionId)
1838                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
1839                    return getPersistence().remove(fileVersionId);
1840            }
1841    
1842            public static DLFileVersion updateImpl(DLFileVersion dlFileVersion) {
1843                    return getPersistence().updateImpl(dlFileVersion);
1844            }
1845    
1846            /**
1847            * Returns the document library file version with the primary key or throws a {@link NoSuchFileVersionException} if it could not be found.
1848            *
1849            * @param fileVersionId the primary key of the document library file version
1850            * @return the document library file version
1851            * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found
1852            */
1853            public static DLFileVersion findByPrimaryKey(long fileVersionId)
1854                    throws com.liferay.portlet.documentlibrary.exception.NoSuchFileVersionException {
1855                    return getPersistence().findByPrimaryKey(fileVersionId);
1856            }
1857    
1858            /**
1859            * Returns the document library file version with the primary key or returns <code>null</code> if it could not be found.
1860            *
1861            * @param fileVersionId the primary key of the document library file version
1862            * @return the document library file version, or <code>null</code> if a document library file version with the primary key could not be found
1863            */
1864            public static DLFileVersion fetchByPrimaryKey(long fileVersionId) {
1865                    return getPersistence().fetchByPrimaryKey(fileVersionId);
1866            }
1867    
1868            public static java.util.Map<java.io.Serializable, DLFileVersion> fetchByPrimaryKeys(
1869                    java.util.Set<java.io.Serializable> primaryKeys) {
1870                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
1871            }
1872    
1873            /**
1874            * Returns all the document library file versions.
1875            *
1876            * @return the document library file versions
1877            */
1878            public static List<DLFileVersion> findAll() {
1879                    return getPersistence().findAll();
1880            }
1881    
1882            /**
1883            * Returns a range of all the document library file versions.
1884            *
1885            * <p>
1886            * 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 DLFileVersionModelImpl}. 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.
1887            * </p>
1888            *
1889            * @param start the lower bound of the range of document library file versions
1890            * @param end the upper bound of the range of document library file versions (not inclusive)
1891            * @return the range of document library file versions
1892            */
1893            public static List<DLFileVersion> findAll(int start, int end) {
1894                    return getPersistence().findAll(start, end);
1895            }
1896    
1897            /**
1898            * Returns an ordered range of all the document library file versions.
1899            *
1900            * <p>
1901            * 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 DLFileVersionModelImpl}. 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.
1902            * </p>
1903            *
1904            * @param start the lower bound of the range of document library file versions
1905            * @param end the upper bound of the range of document library file versions (not inclusive)
1906            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1907            * @return the ordered range of document library file versions
1908            */
1909            public static List<DLFileVersion> findAll(int start, int end,
1910                    OrderByComparator<DLFileVersion> orderByComparator) {
1911                    return getPersistence().findAll(start, end, orderByComparator);
1912            }
1913    
1914            /**
1915            * Returns an ordered range of all the document library file versions.
1916            *
1917            * <p>
1918            * 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 DLFileVersionModelImpl}. 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.
1919            * </p>
1920            *
1921            * @param start the lower bound of the range of document library file versions
1922            * @param end the upper bound of the range of document library file versions (not inclusive)
1923            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1924            * @param retrieveFromCache whether to retrieve from the finder cache
1925            * @return the ordered range of document library file versions
1926            */
1927            public static List<DLFileVersion> findAll(int start, int end,
1928                    OrderByComparator<DLFileVersion> orderByComparator,
1929                    boolean retrieveFromCache) {
1930                    return getPersistence()
1931                                       .findAll(start, end, orderByComparator, retrieveFromCache);
1932            }
1933    
1934            /**
1935            * Removes all the document library file versions from the database.
1936            */
1937            public static void removeAll() {
1938                    getPersistence().removeAll();
1939            }
1940    
1941            /**
1942            * Returns the number of document library file versions.
1943            *
1944            * @return the number of document library file versions
1945            */
1946            public static int countAll() {
1947                    return getPersistence().countAll();
1948            }
1949    
1950            public static java.util.Set<java.lang.String> getBadColumnNames() {
1951                    return getPersistence().getBadColumnNames();
1952            }
1953    
1954            public static DLFileVersionPersistence getPersistence() {
1955                    if (_persistence == null) {
1956                            _persistence = (DLFileVersionPersistence)PortalBeanLocatorUtil.locate(DLFileVersionPersistence.class.getName());
1957    
1958                            ReferenceRegistry.registerReference(DLFileVersionUtil.class,
1959                                    "_persistence");
1960                    }
1961    
1962                    return _persistence;
1963            }
1964    
1965            private static DLFileVersionPersistence _persistence;
1966    }