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