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