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