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.service.persistence.BasePersistence;
020    
021    import com.liferay.portlet.asset.model.AssetVocabulary;
022    
023    /**
024     * The persistence interface for the asset vocabulary service.
025     *
026     * <p>
027     * Caching information and settings can be found in <code>portal.properties</code>
028     * </p>
029     *
030     * @author Brian Wing Shun Chan
031     * @see com.liferay.portlet.asset.service.persistence.impl.AssetVocabularyPersistenceImpl
032     * @see AssetVocabularyUtil
033     * @generated
034     */
035    @ProviderType
036    public interface AssetVocabularyPersistence extends BasePersistence<AssetVocabulary> {
037            /*
038             * NOTE FOR DEVELOPERS:
039             *
040             * Never modify or reference this interface directly. Always use {@link AssetVocabularyUtil} to access the asset vocabulary persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface.
041             */
042    
043            /**
044            * Returns all the asset vocabularies where uuid = &#63;.
045            *
046            * @param uuid the uuid
047            * @return the matching asset vocabularies
048            */
049            public java.util.List<AssetVocabulary> findByUuid(java.lang.String uuid);
050    
051            /**
052            * Returns a range of all the asset vocabularies where uuid = &#63;.
053            *
054            * <p>
055            * 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 AssetVocabularyModelImpl}. 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.
056            * </p>
057            *
058            * @param uuid the uuid
059            * @param start the lower bound of the range of asset vocabularies
060            * @param end the upper bound of the range of asset vocabularies (not inclusive)
061            * @return the range of matching asset vocabularies
062            */
063            public java.util.List<AssetVocabulary> findByUuid(java.lang.String uuid,
064                    int start, int end);
065    
066            /**
067            * Returns an ordered range of all the asset vocabularies where uuid = &#63;.
068            *
069            * <p>
070            * 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 AssetVocabularyModelImpl}. 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.
071            * </p>
072            *
073            * @param uuid the uuid
074            * @param start the lower bound of the range of asset vocabularies
075            * @param end the upper bound of the range of asset vocabularies (not inclusive)
076            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
077            * @return the ordered range of matching asset vocabularies
078            */
079            public java.util.List<AssetVocabulary> findByUuid(java.lang.String uuid,
080                    int start, int end,
081                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator);
082    
083            /**
084            * Returns an ordered range of all the asset vocabularies where uuid = &#63;.
085            *
086            * <p>
087            * 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 AssetVocabularyModelImpl}. 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.
088            * </p>
089            *
090            * @param uuid the uuid
091            * @param start the lower bound of the range of asset vocabularies
092            * @param end the upper bound of the range of asset vocabularies (not inclusive)
093            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
094            * @param retrieveFromCache whether to retrieve from the finder cache
095            * @return the ordered range of matching asset vocabularies
096            */
097            public java.util.List<AssetVocabulary> findByUuid(java.lang.String uuid,
098                    int start, int end,
099                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator,
100                    boolean retrieveFromCache);
101    
102            /**
103            * Returns the first asset vocabulary in the ordered set where uuid = &#63;.
104            *
105            * @param uuid the uuid
106            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
107            * @return the first matching asset vocabulary
108            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
109            */
110            public AssetVocabulary findByUuid_First(java.lang.String uuid,
111                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator)
112                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException;
113    
114            /**
115            * Returns the first asset vocabulary in the ordered set where uuid = &#63;.
116            *
117            * @param uuid the uuid
118            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
119            * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
120            */
121            public AssetVocabulary fetchByUuid_First(java.lang.String uuid,
122                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator);
123    
124            /**
125            * Returns the last asset vocabulary in the ordered set where uuid = &#63;.
126            *
127            * @param uuid the uuid
128            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
129            * @return the last matching asset vocabulary
130            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
131            */
132            public AssetVocabulary findByUuid_Last(java.lang.String uuid,
133                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator)
134                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException;
135    
136            /**
137            * Returns the last asset vocabulary in the ordered set where uuid = &#63;.
138            *
139            * @param uuid the uuid
140            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
141            * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
142            */
143            public AssetVocabulary fetchByUuid_Last(java.lang.String uuid,
144                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator);
145    
146            /**
147            * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where uuid = &#63;.
148            *
149            * @param vocabularyId the primary key of the current asset vocabulary
150            * @param uuid the uuid
151            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
152            * @return the previous, current, and next asset vocabulary
153            * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found
154            */
155            public AssetVocabulary[] findByUuid_PrevAndNext(long vocabularyId,
156                    java.lang.String uuid,
157                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator)
158                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException;
159    
160            /**
161            * Removes all the asset vocabularies where uuid = &#63; from the database.
162            *
163            * @param uuid the uuid
164            */
165            public void removeByUuid(java.lang.String uuid);
166    
167            /**
168            * Returns the number of asset vocabularies where uuid = &#63;.
169            *
170            * @param uuid the uuid
171            * @return the number of matching asset vocabularies
172            */
173            public int countByUuid(java.lang.String uuid);
174    
175            /**
176            * Returns the asset vocabulary where uuid = &#63; and groupId = &#63; or throws a {@link NoSuchVocabularyException} if it could not be found.
177            *
178            * @param uuid the uuid
179            * @param groupId the group ID
180            * @return the matching asset vocabulary
181            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
182            */
183            public AssetVocabulary findByUUID_G(java.lang.String uuid, long groupId)
184                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException;
185    
186            /**
187            * Returns the asset vocabulary where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
188            *
189            * @param uuid the uuid
190            * @param groupId the group ID
191            * @return the matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
192            */
193            public AssetVocabulary fetchByUUID_G(java.lang.String uuid, long groupId);
194    
195            /**
196            * Returns the asset vocabulary where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
197            *
198            * @param uuid the uuid
199            * @param groupId the group ID
200            * @param retrieveFromCache whether to retrieve from the finder cache
201            * @return the matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
202            */
203            public AssetVocabulary fetchByUUID_G(java.lang.String uuid, long groupId,
204                    boolean retrieveFromCache);
205    
206            /**
207            * Removes the asset vocabulary where uuid = &#63; and groupId = &#63; from the database.
208            *
209            * @param uuid the uuid
210            * @param groupId the group ID
211            * @return the asset vocabulary that was removed
212            */
213            public AssetVocabulary removeByUUID_G(java.lang.String uuid, long groupId)
214                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException;
215    
216            /**
217            * Returns the number of asset vocabularies where uuid = &#63; and groupId = &#63;.
218            *
219            * @param uuid the uuid
220            * @param groupId the group ID
221            * @return the number of matching asset vocabularies
222            */
223            public int countByUUID_G(java.lang.String uuid, long groupId);
224    
225            /**
226            * Returns all the asset vocabularies where uuid = &#63; and companyId = &#63;.
227            *
228            * @param uuid the uuid
229            * @param companyId the company ID
230            * @return the matching asset vocabularies
231            */
232            public java.util.List<AssetVocabulary> findByUuid_C(java.lang.String uuid,
233                    long companyId);
234    
235            /**
236            * Returns a range of all the asset vocabularies where uuid = &#63; and companyId = &#63;.
237            *
238            * <p>
239            * 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 AssetVocabularyModelImpl}. 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.
240            * </p>
241            *
242            * @param uuid the uuid
243            * @param companyId the company ID
244            * @param start the lower bound of the range of asset vocabularies
245            * @param end the upper bound of the range of asset vocabularies (not inclusive)
246            * @return the range of matching asset vocabularies
247            */
248            public java.util.List<AssetVocabulary> findByUuid_C(java.lang.String uuid,
249                    long companyId, int start, int end);
250    
251            /**
252            * Returns an ordered range of all the asset vocabularies where uuid = &#63; and companyId = &#63;.
253            *
254            * <p>
255            * 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 AssetVocabularyModelImpl}. 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.
256            * </p>
257            *
258            * @param uuid the uuid
259            * @param companyId the company ID
260            * @param start the lower bound of the range of asset vocabularies
261            * @param end the upper bound of the range of asset vocabularies (not inclusive)
262            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
263            * @return the ordered range of matching asset vocabularies
264            */
265            public java.util.List<AssetVocabulary> findByUuid_C(java.lang.String uuid,
266                    long companyId, int start, int end,
267                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator);
268    
269            /**
270            * Returns an ordered range of all the asset vocabularies where uuid = &#63; and companyId = &#63;.
271            *
272            * <p>
273            * 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 AssetVocabularyModelImpl}. 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.
274            * </p>
275            *
276            * @param uuid the uuid
277            * @param companyId the company ID
278            * @param start the lower bound of the range of asset vocabularies
279            * @param end the upper bound of the range of asset vocabularies (not inclusive)
280            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
281            * @param retrieveFromCache whether to retrieve from the finder cache
282            * @return the ordered range of matching asset vocabularies
283            */
284            public java.util.List<AssetVocabulary> findByUuid_C(java.lang.String uuid,
285                    long companyId, int start, int end,
286                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator,
287                    boolean retrieveFromCache);
288    
289            /**
290            * Returns the first asset vocabulary in the ordered set where uuid = &#63; and companyId = &#63;.
291            *
292            * @param uuid the uuid
293            * @param companyId the company ID
294            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
295            * @return the first matching asset vocabulary
296            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
297            */
298            public AssetVocabulary findByUuid_C_First(java.lang.String uuid,
299                    long companyId,
300                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator)
301                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException;
302    
303            /**
304            * Returns the first asset vocabulary in the ordered set where uuid = &#63; and companyId = &#63;.
305            *
306            * @param uuid the uuid
307            * @param companyId the company ID
308            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
309            * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
310            */
311            public AssetVocabulary fetchByUuid_C_First(java.lang.String uuid,
312                    long companyId,
313                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator);
314    
315            /**
316            * Returns the last asset vocabulary in the ordered set where uuid = &#63; and companyId = &#63;.
317            *
318            * @param uuid the uuid
319            * @param companyId the company ID
320            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
321            * @return the last matching asset vocabulary
322            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
323            */
324            public AssetVocabulary findByUuid_C_Last(java.lang.String uuid,
325                    long companyId,
326                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator)
327                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException;
328    
329            /**
330            * Returns the last asset vocabulary in the ordered set where uuid = &#63; and companyId = &#63;.
331            *
332            * @param uuid the uuid
333            * @param companyId the company ID
334            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
335            * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
336            */
337            public AssetVocabulary fetchByUuid_C_Last(java.lang.String uuid,
338                    long companyId,
339                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator);
340    
341            /**
342            * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where uuid = &#63; and companyId = &#63;.
343            *
344            * @param vocabularyId the primary key of the current asset vocabulary
345            * @param uuid the uuid
346            * @param companyId the company ID
347            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
348            * @return the previous, current, and next asset vocabulary
349            * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found
350            */
351            public AssetVocabulary[] findByUuid_C_PrevAndNext(long vocabularyId,
352                    java.lang.String uuid, long companyId,
353                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator)
354                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException;
355    
356            /**
357            * Removes all the asset vocabularies where uuid = &#63; and companyId = &#63; from the database.
358            *
359            * @param uuid the uuid
360            * @param companyId the company ID
361            */
362            public void removeByUuid_C(java.lang.String uuid, long companyId);
363    
364            /**
365            * Returns the number of asset vocabularies where uuid = &#63; and companyId = &#63;.
366            *
367            * @param uuid the uuid
368            * @param companyId the company ID
369            * @return the number of matching asset vocabularies
370            */
371            public int countByUuid_C(java.lang.String uuid, long companyId);
372    
373            /**
374            * Returns all the asset vocabularies where groupId = &#63;.
375            *
376            * @param groupId the group ID
377            * @return the matching asset vocabularies
378            */
379            public java.util.List<AssetVocabulary> findByGroupId(long groupId);
380    
381            /**
382            * Returns a range of all the asset vocabularies where groupId = &#63;.
383            *
384            * <p>
385            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetVocabularyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
386            * </p>
387            *
388            * @param groupId the group ID
389            * @param start the lower bound of the range of asset vocabularies
390            * @param end the upper bound of the range of asset vocabularies (not inclusive)
391            * @return the range of matching asset vocabularies
392            */
393            public java.util.List<AssetVocabulary> findByGroupId(long groupId,
394                    int start, int end);
395    
396            /**
397            * Returns an ordered range of all the asset vocabularies where groupId = &#63;.
398            *
399            * <p>
400            * 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 AssetVocabularyModelImpl}. 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.
401            * </p>
402            *
403            * @param groupId the group ID
404            * @param start the lower bound of the range of asset vocabularies
405            * @param end the upper bound of the range of asset vocabularies (not inclusive)
406            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
407            * @return the ordered range of matching asset vocabularies
408            */
409            public java.util.List<AssetVocabulary> findByGroupId(long groupId,
410                    int start, int end,
411                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator);
412    
413            /**
414            * Returns an ordered range of all the asset vocabularies where groupId = &#63;.
415            *
416            * <p>
417            * 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 AssetVocabularyModelImpl}. 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.
418            * </p>
419            *
420            * @param groupId the group ID
421            * @param start the lower bound of the range of asset vocabularies
422            * @param end the upper bound of the range of asset vocabularies (not inclusive)
423            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
424            * @param retrieveFromCache whether to retrieve from the finder cache
425            * @return the ordered range of matching asset vocabularies
426            */
427            public java.util.List<AssetVocabulary> findByGroupId(long groupId,
428                    int start, int end,
429                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator,
430                    boolean retrieveFromCache);
431    
432            /**
433            * Returns the first asset vocabulary in the ordered set where groupId = &#63;.
434            *
435            * @param groupId the group ID
436            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
437            * @return the first matching asset vocabulary
438            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
439            */
440            public AssetVocabulary findByGroupId_First(long groupId,
441                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator)
442                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException;
443    
444            /**
445            * Returns the first asset vocabulary in the ordered set where groupId = &#63;.
446            *
447            * @param groupId the group ID
448            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
449            * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
450            */
451            public AssetVocabulary fetchByGroupId_First(long groupId,
452                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator);
453    
454            /**
455            * Returns the last asset vocabulary in the ordered set where groupId = &#63;.
456            *
457            * @param groupId the group ID
458            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
459            * @return the last matching asset vocabulary
460            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
461            */
462            public AssetVocabulary findByGroupId_Last(long groupId,
463                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator)
464                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException;
465    
466            /**
467            * Returns the last asset vocabulary in the ordered set where groupId = &#63;.
468            *
469            * @param groupId the group ID
470            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
471            * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
472            */
473            public AssetVocabulary fetchByGroupId_Last(long groupId,
474                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator);
475    
476            /**
477            * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where groupId = &#63;.
478            *
479            * @param vocabularyId the primary key of the current asset vocabulary
480            * @param groupId the group ID
481            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
482            * @return the previous, current, and next asset vocabulary
483            * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found
484            */
485            public AssetVocabulary[] findByGroupId_PrevAndNext(long vocabularyId,
486                    long groupId,
487                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator)
488                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException;
489    
490            /**
491            * Returns all the asset vocabularies that the user has permission to view where groupId = &#63;.
492            *
493            * @param groupId the group ID
494            * @return the matching asset vocabularies that the user has permission to view
495            */
496            public java.util.List<AssetVocabulary> filterFindByGroupId(long groupId);
497    
498            /**
499            * Returns a range of all the asset vocabularies that the user has permission to view where groupId = &#63;.
500            *
501            * <p>
502            * 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 AssetVocabularyModelImpl}. 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.
503            * </p>
504            *
505            * @param groupId the group ID
506            * @param start the lower bound of the range of asset vocabularies
507            * @param end the upper bound of the range of asset vocabularies (not inclusive)
508            * @return the range of matching asset vocabularies that the user has permission to view
509            */
510            public java.util.List<AssetVocabulary> filterFindByGroupId(long groupId,
511                    int start, int end);
512    
513            /**
514            * Returns an ordered range of all the asset vocabularies that the user has permissions to view where groupId = &#63;.
515            *
516            * <p>
517            * 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 AssetVocabularyModelImpl}. 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.
518            * </p>
519            *
520            * @param groupId the group ID
521            * @param start the lower bound of the range of asset vocabularies
522            * @param end the upper bound of the range of asset vocabularies (not inclusive)
523            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
524            * @return the ordered range of matching asset vocabularies that the user has permission to view
525            */
526            public java.util.List<AssetVocabulary> filterFindByGroupId(long groupId,
527                    int start, int end,
528                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator);
529    
530            /**
531            * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set of asset vocabularies that the user has permission to view where groupId = &#63;.
532            *
533            * @param vocabularyId the primary key of the current asset vocabulary
534            * @param groupId the group ID
535            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
536            * @return the previous, current, and next asset vocabulary
537            * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found
538            */
539            public AssetVocabulary[] filterFindByGroupId_PrevAndNext(
540                    long vocabularyId, long groupId,
541                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator)
542                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException;
543    
544            /**
545            * Returns all the asset vocabularies that the user has permission to view where groupId = any &#63;.
546            *
547            * @param groupIds the group IDs
548            * @return the matching asset vocabularies that the user has permission to view
549            */
550            public java.util.List<AssetVocabulary> filterFindByGroupId(long[] groupIds);
551    
552            /**
553            * Returns a range of all the asset vocabularies that the user has permission to view where groupId = any &#63;.
554            *
555            * <p>
556            * 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 AssetVocabularyModelImpl}. 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.
557            * </p>
558            *
559            * @param groupIds the group IDs
560            * @param start the lower bound of the range of asset vocabularies
561            * @param end the upper bound of the range of asset vocabularies (not inclusive)
562            * @return the range of matching asset vocabularies that the user has permission to view
563            */
564            public java.util.List<AssetVocabulary> filterFindByGroupId(
565                    long[] groupIds, int start, int end);
566    
567            /**
568            * Returns an ordered range of all the asset vocabularies that the user has permission to view where groupId = any &#63;.
569            *
570            * <p>
571            * 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 AssetVocabularyModelImpl}. 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.
572            * </p>
573            *
574            * @param groupIds the group IDs
575            * @param start the lower bound of the range of asset vocabularies
576            * @param end the upper bound of the range of asset vocabularies (not inclusive)
577            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
578            * @return the ordered range of matching asset vocabularies that the user has permission to view
579            */
580            public java.util.List<AssetVocabulary> filterFindByGroupId(
581                    long[] groupIds, int start, int end,
582                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator);
583    
584            /**
585            * Returns all the asset vocabularies where groupId = any &#63;.
586            *
587            * <p>
588            * 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 AssetVocabularyModelImpl}. 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.
589            * </p>
590            *
591            * @param groupIds the group IDs
592            * @return the matching asset vocabularies
593            */
594            public java.util.List<AssetVocabulary> findByGroupId(long[] groupIds);
595    
596            /**
597            * Returns a range of all the asset vocabularies where groupId = any &#63;.
598            *
599            * <p>
600            * 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 AssetVocabularyModelImpl}. 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.
601            * </p>
602            *
603            * @param groupIds the group IDs
604            * @param start the lower bound of the range of asset vocabularies
605            * @param end the upper bound of the range of asset vocabularies (not inclusive)
606            * @return the range of matching asset vocabularies
607            */
608            public java.util.List<AssetVocabulary> findByGroupId(long[] groupIds,
609                    int start, int end);
610    
611            /**
612            * Returns an ordered range of all the asset vocabularies where groupId = any &#63;.
613            *
614            * <p>
615            * 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 AssetVocabularyModelImpl}. 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.
616            * </p>
617            *
618            * @param groupIds the group IDs
619            * @param start the lower bound of the range of asset vocabularies
620            * @param end the upper bound of the range of asset vocabularies (not inclusive)
621            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
622            * @return the ordered range of matching asset vocabularies
623            */
624            public java.util.List<AssetVocabulary> findByGroupId(long[] groupIds,
625                    int start, int end,
626                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator);
627    
628            /**
629            * Returns an ordered range of all the asset vocabularies where groupId = &#63;, optionally using the finder cache.
630            *
631            * <p>
632            * 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 AssetVocabularyModelImpl}. 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.
633            * </p>
634            *
635            * @param groupId the group ID
636            * @param start the lower bound of the range of asset vocabularies
637            * @param end the upper bound of the range of asset vocabularies (not inclusive)
638            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
639            * @param retrieveFromCache whether to retrieve from the finder cache
640            * @return the ordered range of matching asset vocabularies
641            */
642            public java.util.List<AssetVocabulary> findByGroupId(long[] groupIds,
643                    int start, int end,
644                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator,
645                    boolean retrieveFromCache);
646    
647            /**
648            * Removes all the asset vocabularies where groupId = &#63; from the database.
649            *
650            * @param groupId the group ID
651            */
652            public void removeByGroupId(long groupId);
653    
654            /**
655            * Returns the number of asset vocabularies where groupId = &#63;.
656            *
657            * @param groupId the group ID
658            * @return the number of matching asset vocabularies
659            */
660            public int countByGroupId(long groupId);
661    
662            /**
663            * Returns the number of asset vocabularies where groupId = any &#63;.
664            *
665            * @param groupIds the group IDs
666            * @return the number of matching asset vocabularies
667            */
668            public int countByGroupId(long[] groupIds);
669    
670            /**
671            * Returns the number of asset vocabularies that the user has permission to view where groupId = &#63;.
672            *
673            * @param groupId the group ID
674            * @return the number of matching asset vocabularies that the user has permission to view
675            */
676            public int filterCountByGroupId(long groupId);
677    
678            /**
679            * Returns the number of asset vocabularies that the user has permission to view where groupId = any &#63;.
680            *
681            * @param groupIds the group IDs
682            * @return the number of matching asset vocabularies that the user has permission to view
683            */
684            public int filterCountByGroupId(long[] groupIds);
685    
686            /**
687            * Returns all the asset vocabularies where companyId = &#63;.
688            *
689            * @param companyId the company ID
690            * @return the matching asset vocabularies
691            */
692            public java.util.List<AssetVocabulary> findByCompanyId(long companyId);
693    
694            /**
695            * Returns a range of all the asset vocabularies where companyId = &#63;.
696            *
697            * <p>
698            * 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 AssetVocabularyModelImpl}. 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.
699            * </p>
700            *
701            * @param companyId the company ID
702            * @param start the lower bound of the range of asset vocabularies
703            * @param end the upper bound of the range of asset vocabularies (not inclusive)
704            * @return the range of matching asset vocabularies
705            */
706            public java.util.List<AssetVocabulary> findByCompanyId(long companyId,
707                    int start, int end);
708    
709            /**
710            * Returns an ordered range of all the asset vocabularies where companyId = &#63;.
711            *
712            * <p>
713            * 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 AssetVocabularyModelImpl}. 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.
714            * </p>
715            *
716            * @param companyId the company ID
717            * @param start the lower bound of the range of asset vocabularies
718            * @param end the upper bound of the range of asset vocabularies (not inclusive)
719            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
720            * @return the ordered range of matching asset vocabularies
721            */
722            public java.util.List<AssetVocabulary> findByCompanyId(long companyId,
723                    int start, int end,
724                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator);
725    
726            /**
727            * Returns an ordered range of all the asset vocabularies where companyId = &#63;.
728            *
729            * <p>
730            * 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 AssetVocabularyModelImpl}. 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.
731            * </p>
732            *
733            * @param companyId the company ID
734            * @param start the lower bound of the range of asset vocabularies
735            * @param end the upper bound of the range of asset vocabularies (not inclusive)
736            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
737            * @param retrieveFromCache whether to retrieve from the finder cache
738            * @return the ordered range of matching asset vocabularies
739            */
740            public java.util.List<AssetVocabulary> findByCompanyId(long companyId,
741                    int start, int end,
742                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator,
743                    boolean retrieveFromCache);
744    
745            /**
746            * Returns the first asset vocabulary in the ordered set where companyId = &#63;.
747            *
748            * @param companyId the company ID
749            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
750            * @return the first matching asset vocabulary
751            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
752            */
753            public AssetVocabulary findByCompanyId_First(long companyId,
754                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator)
755                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException;
756    
757            /**
758            * Returns the first asset vocabulary in the ordered set where companyId = &#63;.
759            *
760            * @param companyId the company ID
761            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
762            * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
763            */
764            public AssetVocabulary fetchByCompanyId_First(long companyId,
765                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator);
766    
767            /**
768            * Returns the last asset vocabulary in the ordered set where companyId = &#63;.
769            *
770            * @param companyId the company ID
771            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
772            * @return the last matching asset vocabulary
773            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
774            */
775            public AssetVocabulary findByCompanyId_Last(long companyId,
776                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator)
777                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException;
778    
779            /**
780            * Returns the last asset vocabulary in the ordered set where companyId = &#63;.
781            *
782            * @param companyId the company ID
783            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
784            * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
785            */
786            public AssetVocabulary fetchByCompanyId_Last(long companyId,
787                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator);
788    
789            /**
790            * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where companyId = &#63;.
791            *
792            * @param vocabularyId the primary key of the current asset vocabulary
793            * @param companyId the company ID
794            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
795            * @return the previous, current, and next asset vocabulary
796            * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found
797            */
798            public AssetVocabulary[] findByCompanyId_PrevAndNext(long vocabularyId,
799                    long companyId,
800                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator)
801                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException;
802    
803            /**
804            * Removes all the asset vocabularies where companyId = &#63; from the database.
805            *
806            * @param companyId the company ID
807            */
808            public void removeByCompanyId(long companyId);
809    
810            /**
811            * Returns the number of asset vocabularies where companyId = &#63;.
812            *
813            * @param companyId the company ID
814            * @return the number of matching asset vocabularies
815            */
816            public int countByCompanyId(long companyId);
817    
818            /**
819            * Returns the asset vocabulary where groupId = &#63; and name = &#63; or throws a {@link NoSuchVocabularyException} if it could not be found.
820            *
821            * @param groupId the group ID
822            * @param name the name
823            * @return the matching asset vocabulary
824            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
825            */
826            public AssetVocabulary findByG_N(long groupId, java.lang.String name)
827                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException;
828    
829            /**
830            * Returns the asset vocabulary where groupId = &#63; and name = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
831            *
832            * @param groupId the group ID
833            * @param name the name
834            * @return the matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
835            */
836            public AssetVocabulary fetchByG_N(long groupId, java.lang.String name);
837    
838            /**
839            * Returns the asset vocabulary where groupId = &#63; and name = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
840            *
841            * @param groupId the group ID
842            * @param name the name
843            * @param retrieveFromCache whether to retrieve from the finder cache
844            * @return the matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
845            */
846            public AssetVocabulary fetchByG_N(long groupId, java.lang.String name,
847                    boolean retrieveFromCache);
848    
849            /**
850            * Removes the asset vocabulary where groupId = &#63; and name = &#63; from the database.
851            *
852            * @param groupId the group ID
853            * @param name the name
854            * @return the asset vocabulary that was removed
855            */
856            public AssetVocabulary removeByG_N(long groupId, java.lang.String name)
857                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException;
858    
859            /**
860            * Returns the number of asset vocabularies where groupId = &#63; and name = &#63;.
861            *
862            * @param groupId the group ID
863            * @param name the name
864            * @return the number of matching asset vocabularies
865            */
866            public int countByG_N(long groupId, java.lang.String name);
867    
868            /**
869            * Returns all the asset vocabularies where groupId = &#63; and name LIKE &#63;.
870            *
871            * @param groupId the group ID
872            * @param name the name
873            * @return the matching asset vocabularies
874            */
875            public java.util.List<AssetVocabulary> findByG_LikeN(long groupId,
876                    java.lang.String name);
877    
878            /**
879            * Returns a range of all the asset vocabularies where groupId = &#63; and name LIKE &#63;.
880            *
881            * <p>
882            * 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 AssetVocabularyModelImpl}. 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.
883            * </p>
884            *
885            * @param groupId the group ID
886            * @param name the name
887            * @param start the lower bound of the range of asset vocabularies
888            * @param end the upper bound of the range of asset vocabularies (not inclusive)
889            * @return the range of matching asset vocabularies
890            */
891            public java.util.List<AssetVocabulary> findByG_LikeN(long groupId,
892                    java.lang.String name, int start, int end);
893    
894            /**
895            * Returns an ordered range of all the asset vocabularies where groupId = &#63; and name LIKE &#63;.
896            *
897            * <p>
898            * 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 AssetVocabularyModelImpl}. 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.
899            * </p>
900            *
901            * @param groupId the group ID
902            * @param name the name
903            * @param start the lower bound of the range of asset vocabularies
904            * @param end the upper bound of the range of asset vocabularies (not inclusive)
905            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
906            * @return the ordered range of matching asset vocabularies
907            */
908            public java.util.List<AssetVocabulary> findByG_LikeN(long groupId,
909                    java.lang.String name, int start, int end,
910                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator);
911    
912            /**
913            * Returns an ordered range of all the asset vocabularies where groupId = &#63; and name LIKE &#63;.
914            *
915            * <p>
916            * 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 AssetVocabularyModelImpl}. 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.
917            * </p>
918            *
919            * @param groupId the group ID
920            * @param name the name
921            * @param start the lower bound of the range of asset vocabularies
922            * @param end the upper bound of the range of asset vocabularies (not inclusive)
923            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
924            * @param retrieveFromCache whether to retrieve from the finder cache
925            * @return the ordered range of matching asset vocabularies
926            */
927            public java.util.List<AssetVocabulary> findByG_LikeN(long groupId,
928                    java.lang.String name, int start, int end,
929                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator,
930                    boolean retrieveFromCache);
931    
932            /**
933            * Returns the first asset vocabulary in the ordered set where groupId = &#63; and name LIKE &#63;.
934            *
935            * @param groupId the group ID
936            * @param name the name
937            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
938            * @return the first matching asset vocabulary
939            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
940            */
941            public AssetVocabulary findByG_LikeN_First(long groupId,
942                    java.lang.String name,
943                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator)
944                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException;
945    
946            /**
947            * Returns the first asset vocabulary in the ordered set where groupId = &#63; and name LIKE &#63;.
948            *
949            * @param groupId the group ID
950            * @param name the name
951            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
952            * @return the first matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
953            */
954            public AssetVocabulary fetchByG_LikeN_First(long groupId,
955                    java.lang.String name,
956                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator);
957    
958            /**
959            * Returns the last asset vocabulary in the ordered set where groupId = &#63; and name LIKE &#63;.
960            *
961            * @param groupId the group ID
962            * @param name the name
963            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
964            * @return the last matching asset vocabulary
965            * @throws NoSuchVocabularyException if a matching asset vocabulary could not be found
966            */
967            public AssetVocabulary findByG_LikeN_Last(long groupId,
968                    java.lang.String name,
969                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator)
970                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException;
971    
972            /**
973            * Returns the last asset vocabulary in the ordered set where groupId = &#63; and name LIKE &#63;.
974            *
975            * @param groupId the group ID
976            * @param name the name
977            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
978            * @return the last matching asset vocabulary, or <code>null</code> if a matching asset vocabulary could not be found
979            */
980            public AssetVocabulary fetchByG_LikeN_Last(long groupId,
981                    java.lang.String name,
982                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator);
983    
984            /**
985            * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set where groupId = &#63; and name LIKE &#63;.
986            *
987            * @param vocabularyId the primary key of the current asset vocabulary
988            * @param groupId the group ID
989            * @param name the name
990            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
991            * @return the previous, current, and next asset vocabulary
992            * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found
993            */
994            public AssetVocabulary[] findByG_LikeN_PrevAndNext(long vocabularyId,
995                    long groupId, java.lang.String name,
996                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator)
997                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException;
998    
999            /**
1000            * Returns all the asset vocabularies that the user has permission to view where groupId = &#63; and name LIKE &#63;.
1001            *
1002            * @param groupId the group ID
1003            * @param name the name
1004            * @return the matching asset vocabularies that the user has permission to view
1005            */
1006            public java.util.List<AssetVocabulary> filterFindByG_LikeN(long groupId,
1007                    java.lang.String name);
1008    
1009            /**
1010            * Returns a range of all the asset vocabularies that the user has permission to view where groupId = &#63; and name LIKE &#63;.
1011            *
1012            * <p>
1013            * 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 AssetVocabularyModelImpl}. 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.
1014            * </p>
1015            *
1016            * @param groupId the group ID
1017            * @param name the name
1018            * @param start the lower bound of the range of asset vocabularies
1019            * @param end the upper bound of the range of asset vocabularies (not inclusive)
1020            * @return the range of matching asset vocabularies that the user has permission to view
1021            */
1022            public java.util.List<AssetVocabulary> filterFindByG_LikeN(long groupId,
1023                    java.lang.String name, int start, int end);
1024    
1025            /**
1026            * Returns an ordered range of all the asset vocabularies that the user has permissions to view where groupId = &#63; and name LIKE &#63;.
1027            *
1028            * <p>
1029            * 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 AssetVocabularyModelImpl}. 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.
1030            * </p>
1031            *
1032            * @param groupId the group ID
1033            * @param name the name
1034            * @param start the lower bound of the range of asset vocabularies
1035            * @param end the upper bound of the range of asset vocabularies (not inclusive)
1036            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1037            * @return the ordered range of matching asset vocabularies that the user has permission to view
1038            */
1039            public java.util.List<AssetVocabulary> filterFindByG_LikeN(long groupId,
1040                    java.lang.String name, int start, int end,
1041                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator);
1042    
1043            /**
1044            * Returns the asset vocabularies before and after the current asset vocabulary in the ordered set of asset vocabularies that the user has permission to view where groupId = &#63; and name LIKE &#63;.
1045            *
1046            * @param vocabularyId the primary key of the current asset vocabulary
1047            * @param groupId the group ID
1048            * @param name the name
1049            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1050            * @return the previous, current, and next asset vocabulary
1051            * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found
1052            */
1053            public AssetVocabulary[] filterFindByG_LikeN_PrevAndNext(
1054                    long vocabularyId, long groupId, java.lang.String name,
1055                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator)
1056                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException;
1057    
1058            /**
1059            * Removes all the asset vocabularies where groupId = &#63; and name LIKE &#63; from the database.
1060            *
1061            * @param groupId the group ID
1062            * @param name the name
1063            */
1064            public void removeByG_LikeN(long groupId, java.lang.String name);
1065    
1066            /**
1067            * Returns the number of asset vocabularies where groupId = &#63; and name LIKE &#63;.
1068            *
1069            * @param groupId the group ID
1070            * @param name the name
1071            * @return the number of matching asset vocabularies
1072            */
1073            public int countByG_LikeN(long groupId, java.lang.String name);
1074    
1075            /**
1076            * Returns the number of asset vocabularies that the user has permission to view where groupId = &#63; and name LIKE &#63;.
1077            *
1078            * @param groupId the group ID
1079            * @param name the name
1080            * @return the number of matching asset vocabularies that the user has permission to view
1081            */
1082            public int filterCountByG_LikeN(long groupId, java.lang.String name);
1083    
1084            /**
1085            * Caches the asset vocabulary in the entity cache if it is enabled.
1086            *
1087            * @param assetVocabulary the asset vocabulary
1088            */
1089            public void cacheResult(AssetVocabulary assetVocabulary);
1090    
1091            /**
1092            * Caches the asset vocabularies in the entity cache if it is enabled.
1093            *
1094            * @param assetVocabularies the asset vocabularies
1095            */
1096            public void cacheResult(java.util.List<AssetVocabulary> assetVocabularies);
1097    
1098            /**
1099            * Creates a new asset vocabulary with the primary key. Does not add the asset vocabulary to the database.
1100            *
1101            * @param vocabularyId the primary key for the new asset vocabulary
1102            * @return the new asset vocabulary
1103            */
1104            public AssetVocabulary create(long vocabularyId);
1105    
1106            /**
1107            * Removes the asset vocabulary with the primary key from the database. Also notifies the appropriate model listeners.
1108            *
1109            * @param vocabularyId the primary key of the asset vocabulary
1110            * @return the asset vocabulary that was removed
1111            * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found
1112            */
1113            public AssetVocabulary remove(long vocabularyId)
1114                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException;
1115    
1116            public AssetVocabulary updateImpl(AssetVocabulary assetVocabulary);
1117    
1118            /**
1119            * Returns the asset vocabulary with the primary key or throws a {@link NoSuchVocabularyException} if it could not be found.
1120            *
1121            * @param vocabularyId the primary key of the asset vocabulary
1122            * @return the asset vocabulary
1123            * @throws NoSuchVocabularyException if a asset vocabulary with the primary key could not be found
1124            */
1125            public AssetVocabulary findByPrimaryKey(long vocabularyId)
1126                    throws com.liferay.portlet.asset.exception.NoSuchVocabularyException;
1127    
1128            /**
1129            * Returns the asset vocabulary with the primary key or returns <code>null</code> if it could not be found.
1130            *
1131            * @param vocabularyId the primary key of the asset vocabulary
1132            * @return the asset vocabulary, or <code>null</code> if a asset vocabulary with the primary key could not be found
1133            */
1134            public AssetVocabulary fetchByPrimaryKey(long vocabularyId);
1135    
1136            @Override
1137            public java.util.Map<java.io.Serializable, AssetVocabulary> fetchByPrimaryKeys(
1138                    java.util.Set<java.io.Serializable> primaryKeys);
1139    
1140            /**
1141            * Returns all the asset vocabularies.
1142            *
1143            * @return the asset vocabularies
1144            */
1145            public java.util.List<AssetVocabulary> findAll();
1146    
1147            /**
1148            * Returns a range of all the asset vocabularies.
1149            *
1150            * <p>
1151            * 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 AssetVocabularyModelImpl}. 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.
1152            * </p>
1153            *
1154            * @param start the lower bound of the range of asset vocabularies
1155            * @param end the upper bound of the range of asset vocabularies (not inclusive)
1156            * @return the range of asset vocabularies
1157            */
1158            public java.util.List<AssetVocabulary> findAll(int start, int end);
1159    
1160            /**
1161            * Returns an ordered range of all the asset vocabularies.
1162            *
1163            * <p>
1164            * 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 AssetVocabularyModelImpl}. 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.
1165            * </p>
1166            *
1167            * @param start the lower bound of the range of asset vocabularies
1168            * @param end the upper bound of the range of asset vocabularies (not inclusive)
1169            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1170            * @return the ordered range of asset vocabularies
1171            */
1172            public java.util.List<AssetVocabulary> findAll(int start, int end,
1173                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator);
1174    
1175            /**
1176            * Returns an ordered range of all the asset vocabularies.
1177            *
1178            * <p>
1179            * 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 AssetVocabularyModelImpl}. 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.
1180            * </p>
1181            *
1182            * @param start the lower bound of the range of asset vocabularies
1183            * @param end the upper bound of the range of asset vocabularies (not inclusive)
1184            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1185            * @param retrieveFromCache whether to retrieve from the finder cache
1186            * @return the ordered range of asset vocabularies
1187            */
1188            public java.util.List<AssetVocabulary> findAll(int start, int end,
1189                    com.liferay.portal.kernel.util.OrderByComparator<AssetVocabulary> orderByComparator,
1190                    boolean retrieveFromCache);
1191    
1192            /**
1193            * Removes all the asset vocabularies from the database.
1194            */
1195            public void removeAll();
1196    
1197            /**
1198            * Returns the number of asset vocabularies.
1199            *
1200            * @return the number of asset vocabularies
1201            */
1202            public int countAll();
1203    
1204            @Override
1205            public java.util.Set<java.lang.String> getBadColumnNames();
1206    }