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.asset.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.asset.model.AssetCategoryProperty;
026    
027    import java.util.List;
028    
029    /**
030     * The persistence utility for the asset category property service. This utility wraps {@link com.liferay.portlet.asset.service.persistence.impl.AssetCategoryPropertyPersistenceImpl} 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 AssetCategoryPropertyPersistence
038     * @see com.liferay.portlet.asset.service.persistence.impl.AssetCategoryPropertyPersistenceImpl
039     * @generated
040     */
041    @ProviderType
042    public class AssetCategoryPropertyUtil {
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(AssetCategoryProperty assetCategoryProperty) {
060                    getPersistence().clearCache(assetCategoryProperty);
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<AssetCategoryProperty> 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<AssetCategoryProperty> 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<AssetCategoryProperty> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator<AssetCategoryProperty> 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 AssetCategoryProperty update(
101                    AssetCategoryProperty assetCategoryProperty) {
102                    return getPersistence().update(assetCategoryProperty);
103            }
104    
105            /**
106             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
107             */
108            public static AssetCategoryProperty update(
109                    AssetCategoryProperty assetCategoryProperty,
110                    ServiceContext serviceContext) {
111                    return getPersistence().update(assetCategoryProperty, serviceContext);
112            }
113    
114            /**
115            * Returns all the asset category properties where companyId = &#63;.
116            *
117            * @param companyId the company ID
118            * @return the matching asset category properties
119            */
120            public static List<AssetCategoryProperty> findByCompanyId(long companyId) {
121                    return getPersistence().findByCompanyId(companyId);
122            }
123    
124            /**
125            * Returns a range of all the asset category properties where companyId = &#63;.
126            *
127            * <p>
128            * 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 AssetCategoryPropertyModelImpl}. 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.
129            * </p>
130            *
131            * @param companyId the company ID
132            * @param start the lower bound of the range of asset category properties
133            * @param end the upper bound of the range of asset category properties (not inclusive)
134            * @return the range of matching asset category properties
135            */
136            public static List<AssetCategoryProperty> findByCompanyId(long companyId,
137                    int start, int end) {
138                    return getPersistence().findByCompanyId(companyId, start, end);
139            }
140    
141            /**
142            * Returns an ordered range of all the asset category properties where companyId = &#63;.
143            *
144            * <p>
145            * 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 AssetCategoryPropertyModelImpl}. 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.
146            * </p>
147            *
148            * @param companyId the company ID
149            * @param start the lower bound of the range of asset category properties
150            * @param end the upper bound of the range of asset category properties (not inclusive)
151            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
152            * @return the ordered range of matching asset category properties
153            */
154            public static List<AssetCategoryProperty> findByCompanyId(long companyId,
155                    int start, int end,
156                    OrderByComparator<AssetCategoryProperty> orderByComparator) {
157                    return getPersistence()
158                                       .findByCompanyId(companyId, start, end, orderByComparator);
159            }
160    
161            /**
162            * Returns an ordered range of all the asset category properties where companyId = &#63;.
163            *
164            * <p>
165            * 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 AssetCategoryPropertyModelImpl}. 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.
166            * </p>
167            *
168            * @param companyId the company ID
169            * @param start the lower bound of the range of asset category properties
170            * @param end the upper bound of the range of asset category properties (not inclusive)
171            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
172            * @param retrieveFromCache whether to retrieve from the finder cache
173            * @return the ordered range of matching asset category properties
174            */
175            public static List<AssetCategoryProperty> findByCompanyId(long companyId,
176                    int start, int end,
177                    OrderByComparator<AssetCategoryProperty> orderByComparator,
178                    boolean retrieveFromCache) {
179                    return getPersistence()
180                                       .findByCompanyId(companyId, start, end, orderByComparator,
181                            retrieveFromCache);
182            }
183    
184            /**
185            * Returns the first asset category property in the ordered set where companyId = &#63;.
186            *
187            * @param companyId the company ID
188            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
189            * @return the first matching asset category property
190            * @throws NoSuchCategoryPropertyException if a matching asset category property could not be found
191            */
192            public static AssetCategoryProperty findByCompanyId_First(long companyId,
193                    OrderByComparator<AssetCategoryProperty> orderByComparator)
194                    throws com.liferay.portlet.asset.exception.NoSuchCategoryPropertyException {
195                    return getPersistence()
196                                       .findByCompanyId_First(companyId, orderByComparator);
197            }
198    
199            /**
200            * Returns the first asset category property in the ordered set where companyId = &#63;.
201            *
202            * @param companyId the company ID
203            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
204            * @return the first matching asset category property, or <code>null</code> if a matching asset category property could not be found
205            */
206            public static AssetCategoryProperty fetchByCompanyId_First(long companyId,
207                    OrderByComparator<AssetCategoryProperty> orderByComparator) {
208                    return getPersistence()
209                                       .fetchByCompanyId_First(companyId, orderByComparator);
210            }
211    
212            /**
213            * Returns the last asset category property in the ordered set where companyId = &#63;.
214            *
215            * @param companyId the company ID
216            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
217            * @return the last matching asset category property
218            * @throws NoSuchCategoryPropertyException if a matching asset category property could not be found
219            */
220            public static AssetCategoryProperty findByCompanyId_Last(long companyId,
221                    OrderByComparator<AssetCategoryProperty> orderByComparator)
222                    throws com.liferay.portlet.asset.exception.NoSuchCategoryPropertyException {
223                    return getPersistence()
224                                       .findByCompanyId_Last(companyId, orderByComparator);
225            }
226    
227            /**
228            * Returns the last asset category property in the ordered set where companyId = &#63;.
229            *
230            * @param companyId the company ID
231            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
232            * @return the last matching asset category property, or <code>null</code> if a matching asset category property could not be found
233            */
234            public static AssetCategoryProperty fetchByCompanyId_Last(long companyId,
235                    OrderByComparator<AssetCategoryProperty> orderByComparator) {
236                    return getPersistence()
237                                       .fetchByCompanyId_Last(companyId, orderByComparator);
238            }
239    
240            /**
241            * Returns the asset category properties before and after the current asset category property in the ordered set where companyId = &#63;.
242            *
243            * @param categoryPropertyId the primary key of the current asset category property
244            * @param companyId the company ID
245            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
246            * @return the previous, current, and next asset category property
247            * @throws NoSuchCategoryPropertyException if a asset category property with the primary key could not be found
248            */
249            public static AssetCategoryProperty[] findByCompanyId_PrevAndNext(
250                    long categoryPropertyId, long companyId,
251                    OrderByComparator<AssetCategoryProperty> orderByComparator)
252                    throws com.liferay.portlet.asset.exception.NoSuchCategoryPropertyException {
253                    return getPersistence()
254                                       .findByCompanyId_PrevAndNext(categoryPropertyId, companyId,
255                            orderByComparator);
256            }
257    
258            /**
259            * Removes all the asset category properties where companyId = &#63; from the database.
260            *
261            * @param companyId the company ID
262            */
263            public static void removeByCompanyId(long companyId) {
264                    getPersistence().removeByCompanyId(companyId);
265            }
266    
267            /**
268            * Returns the number of asset category properties where companyId = &#63;.
269            *
270            * @param companyId the company ID
271            * @return the number of matching asset category properties
272            */
273            public static int countByCompanyId(long companyId) {
274                    return getPersistence().countByCompanyId(companyId);
275            }
276    
277            /**
278            * Returns all the asset category properties where categoryId = &#63;.
279            *
280            * @param categoryId the category ID
281            * @return the matching asset category properties
282            */
283            public static List<AssetCategoryProperty> findByCategoryId(long categoryId) {
284                    return getPersistence().findByCategoryId(categoryId);
285            }
286    
287            /**
288            * Returns a range of all the asset category properties where categoryId = &#63;.
289            *
290            * <p>
291            * 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 AssetCategoryPropertyModelImpl}. 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.
292            * </p>
293            *
294            * @param categoryId the category ID
295            * @param start the lower bound of the range of asset category properties
296            * @param end the upper bound of the range of asset category properties (not inclusive)
297            * @return the range of matching asset category properties
298            */
299            public static List<AssetCategoryProperty> findByCategoryId(
300                    long categoryId, int start, int end) {
301                    return getPersistence().findByCategoryId(categoryId, start, end);
302            }
303    
304            /**
305            * Returns an ordered range of all the asset category properties where categoryId = &#63;.
306            *
307            * <p>
308            * 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 AssetCategoryPropertyModelImpl}. 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.
309            * </p>
310            *
311            * @param categoryId the category ID
312            * @param start the lower bound of the range of asset category properties
313            * @param end the upper bound of the range of asset category properties (not inclusive)
314            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
315            * @return the ordered range of matching asset category properties
316            */
317            public static List<AssetCategoryProperty> findByCategoryId(
318                    long categoryId, int start, int end,
319                    OrderByComparator<AssetCategoryProperty> orderByComparator) {
320                    return getPersistence()
321                                       .findByCategoryId(categoryId, start, end, orderByComparator);
322            }
323    
324            /**
325            * Returns an ordered range of all the asset category properties where categoryId = &#63;.
326            *
327            * <p>
328            * 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 AssetCategoryPropertyModelImpl}. 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.
329            * </p>
330            *
331            * @param categoryId the category ID
332            * @param start the lower bound of the range of asset category properties
333            * @param end the upper bound of the range of asset category properties (not inclusive)
334            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
335            * @param retrieveFromCache whether to retrieve from the finder cache
336            * @return the ordered range of matching asset category properties
337            */
338            public static List<AssetCategoryProperty> findByCategoryId(
339                    long categoryId, int start, int end,
340                    OrderByComparator<AssetCategoryProperty> orderByComparator,
341                    boolean retrieveFromCache) {
342                    return getPersistence()
343                                       .findByCategoryId(categoryId, start, end, orderByComparator,
344                            retrieveFromCache);
345            }
346    
347            /**
348            * Returns the first asset category property in the ordered set where categoryId = &#63;.
349            *
350            * @param categoryId the category ID
351            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
352            * @return the first matching asset category property
353            * @throws NoSuchCategoryPropertyException if a matching asset category property could not be found
354            */
355            public static AssetCategoryProperty findByCategoryId_First(
356                    long categoryId,
357                    OrderByComparator<AssetCategoryProperty> orderByComparator)
358                    throws com.liferay.portlet.asset.exception.NoSuchCategoryPropertyException {
359                    return getPersistence()
360                                       .findByCategoryId_First(categoryId, orderByComparator);
361            }
362    
363            /**
364            * Returns the first asset category property in the ordered set where categoryId = &#63;.
365            *
366            * @param categoryId the category ID
367            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
368            * @return the first matching asset category property, or <code>null</code> if a matching asset category property could not be found
369            */
370            public static AssetCategoryProperty fetchByCategoryId_First(
371                    long categoryId,
372                    OrderByComparator<AssetCategoryProperty> orderByComparator) {
373                    return getPersistence()
374                                       .fetchByCategoryId_First(categoryId, orderByComparator);
375            }
376    
377            /**
378            * Returns the last asset category property in the ordered set where categoryId = &#63;.
379            *
380            * @param categoryId the category ID
381            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
382            * @return the last matching asset category property
383            * @throws NoSuchCategoryPropertyException if a matching asset category property could not be found
384            */
385            public static AssetCategoryProperty findByCategoryId_Last(long categoryId,
386                    OrderByComparator<AssetCategoryProperty> orderByComparator)
387                    throws com.liferay.portlet.asset.exception.NoSuchCategoryPropertyException {
388                    return getPersistence()
389                                       .findByCategoryId_Last(categoryId, orderByComparator);
390            }
391    
392            /**
393            * Returns the last asset category property in the ordered set where categoryId = &#63;.
394            *
395            * @param categoryId the category ID
396            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
397            * @return the last matching asset category property, or <code>null</code> if a matching asset category property could not be found
398            */
399            public static AssetCategoryProperty fetchByCategoryId_Last(
400                    long categoryId,
401                    OrderByComparator<AssetCategoryProperty> orderByComparator) {
402                    return getPersistence()
403                                       .fetchByCategoryId_Last(categoryId, orderByComparator);
404            }
405    
406            /**
407            * Returns the asset category properties before and after the current asset category property in the ordered set where categoryId = &#63;.
408            *
409            * @param categoryPropertyId the primary key of the current asset category property
410            * @param categoryId the category ID
411            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
412            * @return the previous, current, and next asset category property
413            * @throws NoSuchCategoryPropertyException if a asset category property with the primary key could not be found
414            */
415            public static AssetCategoryProperty[] findByCategoryId_PrevAndNext(
416                    long categoryPropertyId, long categoryId,
417                    OrderByComparator<AssetCategoryProperty> orderByComparator)
418                    throws com.liferay.portlet.asset.exception.NoSuchCategoryPropertyException {
419                    return getPersistence()
420                                       .findByCategoryId_PrevAndNext(categoryPropertyId,
421                            categoryId, orderByComparator);
422            }
423    
424            /**
425            * Removes all the asset category properties where categoryId = &#63; from the database.
426            *
427            * @param categoryId the category ID
428            */
429            public static void removeByCategoryId(long categoryId) {
430                    getPersistence().removeByCategoryId(categoryId);
431            }
432    
433            /**
434            * Returns the number of asset category properties where categoryId = &#63;.
435            *
436            * @param categoryId the category ID
437            * @return the number of matching asset category properties
438            */
439            public static int countByCategoryId(long categoryId) {
440                    return getPersistence().countByCategoryId(categoryId);
441            }
442    
443            /**
444            * Returns all the asset category properties where companyId = &#63; and key = &#63;.
445            *
446            * @param companyId the company ID
447            * @param key the key
448            * @return the matching asset category properties
449            */
450            public static List<AssetCategoryProperty> findByC_K(long companyId,
451                    java.lang.String key) {
452                    return getPersistence().findByC_K(companyId, key);
453            }
454    
455            /**
456            * Returns a range of all the asset category properties where companyId = &#63; and key = &#63;.
457            *
458            * <p>
459            * 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 AssetCategoryPropertyModelImpl}. 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.
460            * </p>
461            *
462            * @param companyId the company ID
463            * @param key the key
464            * @param start the lower bound of the range of asset category properties
465            * @param end the upper bound of the range of asset category properties (not inclusive)
466            * @return the range of matching asset category properties
467            */
468            public static List<AssetCategoryProperty> findByC_K(long companyId,
469                    java.lang.String key, int start, int end) {
470                    return getPersistence().findByC_K(companyId, key, start, end);
471            }
472    
473            /**
474            * Returns an ordered range of all the asset category properties where companyId = &#63; and key = &#63;.
475            *
476            * <p>
477            * 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 AssetCategoryPropertyModelImpl}. 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.
478            * </p>
479            *
480            * @param companyId the company ID
481            * @param key the key
482            * @param start the lower bound of the range of asset category properties
483            * @param end the upper bound of the range of asset category properties (not inclusive)
484            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
485            * @return the ordered range of matching asset category properties
486            */
487            public static List<AssetCategoryProperty> findByC_K(long companyId,
488                    java.lang.String key, int start, int end,
489                    OrderByComparator<AssetCategoryProperty> orderByComparator) {
490                    return getPersistence()
491                                       .findByC_K(companyId, key, start, end, orderByComparator);
492            }
493    
494            /**
495            * Returns an ordered range of all the asset category properties where companyId = &#63; and key = &#63;.
496            *
497            * <p>
498            * 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 AssetCategoryPropertyModelImpl}. 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.
499            * </p>
500            *
501            * @param companyId the company ID
502            * @param key the key
503            * @param start the lower bound of the range of asset category properties
504            * @param end the upper bound of the range of asset category properties (not inclusive)
505            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
506            * @param retrieveFromCache whether to retrieve from the finder cache
507            * @return the ordered range of matching asset category properties
508            */
509            public static List<AssetCategoryProperty> findByC_K(long companyId,
510                    java.lang.String key, int start, int end,
511                    OrderByComparator<AssetCategoryProperty> orderByComparator,
512                    boolean retrieveFromCache) {
513                    return getPersistence()
514                                       .findByC_K(companyId, key, start, end, orderByComparator,
515                            retrieveFromCache);
516            }
517    
518            /**
519            * Returns the first asset category property in the ordered set where companyId = &#63; and key = &#63;.
520            *
521            * @param companyId the company ID
522            * @param key the key
523            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
524            * @return the first matching asset category property
525            * @throws NoSuchCategoryPropertyException if a matching asset category property could not be found
526            */
527            public static AssetCategoryProperty findByC_K_First(long companyId,
528                    java.lang.String key,
529                    OrderByComparator<AssetCategoryProperty> orderByComparator)
530                    throws com.liferay.portlet.asset.exception.NoSuchCategoryPropertyException {
531                    return getPersistence()
532                                       .findByC_K_First(companyId, key, orderByComparator);
533            }
534    
535            /**
536            * Returns the first asset category property in the ordered set where companyId = &#63; and key = &#63;.
537            *
538            * @param companyId the company ID
539            * @param key the key
540            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
541            * @return the first matching asset category property, or <code>null</code> if a matching asset category property could not be found
542            */
543            public static AssetCategoryProperty fetchByC_K_First(long companyId,
544                    java.lang.String key,
545                    OrderByComparator<AssetCategoryProperty> orderByComparator) {
546                    return getPersistence()
547                                       .fetchByC_K_First(companyId, key, orderByComparator);
548            }
549    
550            /**
551            * Returns the last asset category property in the ordered set where companyId = &#63; and key = &#63;.
552            *
553            * @param companyId the company ID
554            * @param key the key
555            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
556            * @return the last matching asset category property
557            * @throws NoSuchCategoryPropertyException if a matching asset category property could not be found
558            */
559            public static AssetCategoryProperty findByC_K_Last(long companyId,
560                    java.lang.String key,
561                    OrderByComparator<AssetCategoryProperty> orderByComparator)
562                    throws com.liferay.portlet.asset.exception.NoSuchCategoryPropertyException {
563                    return getPersistence().findByC_K_Last(companyId, key, orderByComparator);
564            }
565    
566            /**
567            * Returns the last asset category property in the ordered set where companyId = &#63; and key = &#63;.
568            *
569            * @param companyId the company ID
570            * @param key the key
571            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
572            * @return the last matching asset category property, or <code>null</code> if a matching asset category property could not be found
573            */
574            public static AssetCategoryProperty fetchByC_K_Last(long companyId,
575                    java.lang.String key,
576                    OrderByComparator<AssetCategoryProperty> orderByComparator) {
577                    return getPersistence()
578                                       .fetchByC_K_Last(companyId, key, orderByComparator);
579            }
580    
581            /**
582            * Returns the asset category properties before and after the current asset category property in the ordered set where companyId = &#63; and key = &#63;.
583            *
584            * @param categoryPropertyId the primary key of the current asset category property
585            * @param companyId the company ID
586            * @param key the key
587            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
588            * @return the previous, current, and next asset category property
589            * @throws NoSuchCategoryPropertyException if a asset category property with the primary key could not be found
590            */
591            public static AssetCategoryProperty[] findByC_K_PrevAndNext(
592                    long categoryPropertyId, long companyId, java.lang.String key,
593                    OrderByComparator<AssetCategoryProperty> orderByComparator)
594                    throws com.liferay.portlet.asset.exception.NoSuchCategoryPropertyException {
595                    return getPersistence()
596                                       .findByC_K_PrevAndNext(categoryPropertyId, companyId, key,
597                            orderByComparator);
598            }
599    
600            /**
601            * Removes all the asset category properties where companyId = &#63; and key = &#63; from the database.
602            *
603            * @param companyId the company ID
604            * @param key the key
605            */
606            public static void removeByC_K(long companyId, java.lang.String key) {
607                    getPersistence().removeByC_K(companyId, key);
608            }
609    
610            /**
611            * Returns the number of asset category properties where companyId = &#63; and key = &#63;.
612            *
613            * @param companyId the company ID
614            * @param key the key
615            * @return the number of matching asset category properties
616            */
617            public static int countByC_K(long companyId, java.lang.String key) {
618                    return getPersistence().countByC_K(companyId, key);
619            }
620    
621            /**
622            * Returns the asset category property where categoryId = &#63; and key = &#63; or throws a {@link NoSuchCategoryPropertyException} if it could not be found.
623            *
624            * @param categoryId the category ID
625            * @param key the key
626            * @return the matching asset category property
627            * @throws NoSuchCategoryPropertyException if a matching asset category property could not be found
628            */
629            public static AssetCategoryProperty findByCA_K(long categoryId,
630                    java.lang.String key)
631                    throws com.liferay.portlet.asset.exception.NoSuchCategoryPropertyException {
632                    return getPersistence().findByCA_K(categoryId, key);
633            }
634    
635            /**
636            * Returns the asset category property where categoryId = &#63; and key = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
637            *
638            * @param categoryId the category ID
639            * @param key the key
640            * @return the matching asset category property, or <code>null</code> if a matching asset category property could not be found
641            */
642            public static AssetCategoryProperty fetchByCA_K(long categoryId,
643                    java.lang.String key) {
644                    return getPersistence().fetchByCA_K(categoryId, key);
645            }
646    
647            /**
648            * Returns the asset category property where categoryId = &#63; and key = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
649            *
650            * @param categoryId the category ID
651            * @param key the key
652            * @param retrieveFromCache whether to retrieve from the finder cache
653            * @return the matching asset category property, or <code>null</code> if a matching asset category property could not be found
654            */
655            public static AssetCategoryProperty fetchByCA_K(long categoryId,
656                    java.lang.String key, boolean retrieveFromCache) {
657                    return getPersistence().fetchByCA_K(categoryId, key, retrieveFromCache);
658            }
659    
660            /**
661            * Removes the asset category property where categoryId = &#63; and key = &#63; from the database.
662            *
663            * @param categoryId the category ID
664            * @param key the key
665            * @return the asset category property that was removed
666            */
667            public static AssetCategoryProperty removeByCA_K(long categoryId,
668                    java.lang.String key)
669                    throws com.liferay.portlet.asset.exception.NoSuchCategoryPropertyException {
670                    return getPersistence().removeByCA_K(categoryId, key);
671            }
672    
673            /**
674            * Returns the number of asset category properties where categoryId = &#63; and key = &#63;.
675            *
676            * @param categoryId the category ID
677            * @param key the key
678            * @return the number of matching asset category properties
679            */
680            public static int countByCA_K(long categoryId, java.lang.String key) {
681                    return getPersistence().countByCA_K(categoryId, key);
682            }
683    
684            /**
685            * Caches the asset category property in the entity cache if it is enabled.
686            *
687            * @param assetCategoryProperty the asset category property
688            */
689            public static void cacheResult(AssetCategoryProperty assetCategoryProperty) {
690                    getPersistence().cacheResult(assetCategoryProperty);
691            }
692    
693            /**
694            * Caches the asset category properties in the entity cache if it is enabled.
695            *
696            * @param assetCategoryProperties the asset category properties
697            */
698            public static void cacheResult(
699                    List<AssetCategoryProperty> assetCategoryProperties) {
700                    getPersistence().cacheResult(assetCategoryProperties);
701            }
702    
703            /**
704            * Creates a new asset category property with the primary key. Does not add the asset category property to the database.
705            *
706            * @param categoryPropertyId the primary key for the new asset category property
707            * @return the new asset category property
708            */
709            public static AssetCategoryProperty create(long categoryPropertyId) {
710                    return getPersistence().create(categoryPropertyId);
711            }
712    
713            /**
714            * Removes the asset category property with the primary key from the database. Also notifies the appropriate model listeners.
715            *
716            * @param categoryPropertyId the primary key of the asset category property
717            * @return the asset category property that was removed
718            * @throws NoSuchCategoryPropertyException if a asset category property with the primary key could not be found
719            */
720            public static AssetCategoryProperty remove(long categoryPropertyId)
721                    throws com.liferay.portlet.asset.exception.NoSuchCategoryPropertyException {
722                    return getPersistence().remove(categoryPropertyId);
723            }
724    
725            public static AssetCategoryProperty updateImpl(
726                    AssetCategoryProperty assetCategoryProperty) {
727                    return getPersistence().updateImpl(assetCategoryProperty);
728            }
729    
730            /**
731            * Returns the asset category property with the primary key or throws a {@link NoSuchCategoryPropertyException} if it could not be found.
732            *
733            * @param categoryPropertyId the primary key of the asset category property
734            * @return the asset category property
735            * @throws NoSuchCategoryPropertyException if a asset category property with the primary key could not be found
736            */
737            public static AssetCategoryProperty findByPrimaryKey(
738                    long categoryPropertyId)
739                    throws com.liferay.portlet.asset.exception.NoSuchCategoryPropertyException {
740                    return getPersistence().findByPrimaryKey(categoryPropertyId);
741            }
742    
743            /**
744            * Returns the asset category property with the primary key or returns <code>null</code> if it could not be found.
745            *
746            * @param categoryPropertyId the primary key of the asset category property
747            * @return the asset category property, or <code>null</code> if a asset category property with the primary key could not be found
748            */
749            public static AssetCategoryProperty fetchByPrimaryKey(
750                    long categoryPropertyId) {
751                    return getPersistence().fetchByPrimaryKey(categoryPropertyId);
752            }
753    
754            public static java.util.Map<java.io.Serializable, AssetCategoryProperty> fetchByPrimaryKeys(
755                    java.util.Set<java.io.Serializable> primaryKeys) {
756                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
757            }
758    
759            /**
760            * Returns all the asset category properties.
761            *
762            * @return the asset category properties
763            */
764            public static List<AssetCategoryProperty> findAll() {
765                    return getPersistence().findAll();
766            }
767    
768            /**
769            * Returns a range of all the asset category properties.
770            *
771            * <p>
772            * 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 AssetCategoryPropertyModelImpl}. 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.
773            * </p>
774            *
775            * @param start the lower bound of the range of asset category properties
776            * @param end the upper bound of the range of asset category properties (not inclusive)
777            * @return the range of asset category properties
778            */
779            public static List<AssetCategoryProperty> findAll(int start, int end) {
780                    return getPersistence().findAll(start, end);
781            }
782    
783            /**
784            * Returns an ordered range of all the asset category properties.
785            *
786            * <p>
787            * 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 AssetCategoryPropertyModelImpl}. 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.
788            * </p>
789            *
790            * @param start the lower bound of the range of asset category properties
791            * @param end the upper bound of the range of asset category properties (not inclusive)
792            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
793            * @return the ordered range of asset category properties
794            */
795            public static List<AssetCategoryProperty> findAll(int start, int end,
796                    OrderByComparator<AssetCategoryProperty> orderByComparator) {
797                    return getPersistence().findAll(start, end, orderByComparator);
798            }
799    
800            /**
801            * Returns an ordered range of all the asset category properties.
802            *
803            * <p>
804            * 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 AssetCategoryPropertyModelImpl}. 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.
805            * </p>
806            *
807            * @param start the lower bound of the range of asset category properties
808            * @param end the upper bound of the range of asset category properties (not inclusive)
809            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
810            * @param retrieveFromCache whether to retrieve from the finder cache
811            * @return the ordered range of asset category properties
812            */
813            public static List<AssetCategoryProperty> findAll(int start, int end,
814                    OrderByComparator<AssetCategoryProperty> orderByComparator,
815                    boolean retrieveFromCache) {
816                    return getPersistence()
817                                       .findAll(start, end, orderByComparator, retrieveFromCache);
818            }
819    
820            /**
821            * Removes all the asset category properties from the database.
822            */
823            public static void removeAll() {
824                    getPersistence().removeAll();
825            }
826    
827            /**
828            * Returns the number of asset category properties.
829            *
830            * @return the number of asset category properties
831            */
832            public static int countAll() {
833                    return getPersistence().countAll();
834            }
835    
836            public static java.util.Set<java.lang.String> getBadColumnNames() {
837                    return getPersistence().getBadColumnNames();
838            }
839    
840            public static AssetCategoryPropertyPersistence getPersistence() {
841                    if (_persistence == null) {
842                            _persistence = (AssetCategoryPropertyPersistence)PortalBeanLocatorUtil.locate(AssetCategoryPropertyPersistence.class.getName());
843    
844                            ReferenceRegistry.registerReference(AssetCategoryPropertyUtil.class,
845                                    "_persistence");
846                    }
847    
848                    return _persistence;
849            }
850    
851            private static AssetCategoryPropertyPersistence _persistence;
852    }