001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.asset.service.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
020    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
021    import com.liferay.portal.kernel.util.OrderByComparator;
022    import com.liferay.portal.kernel.util.ReferenceRegistry;
023    import com.liferay.portal.service.ServiceContext;
024    
025    import com.liferay.portlet.asset.model.AssetTag;
026    
027    import java.util.List;
028    
029    /**
030     * The persistence utility for the asset tag service. This utility wraps {@link com.liferay.portlet.asset.service.persistence.impl.AssetTagPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
031     *
032     * <p>
033     * Caching information and settings can be found in <code>portal.properties</code>
034     * </p>
035     *
036     * @author Brian Wing Shun Chan
037     * @see AssetTagPersistence
038     * @see com.liferay.portlet.asset.service.persistence.impl.AssetTagPersistenceImpl
039     * @generated
040     */
041    @ProviderType
042    public class AssetTagUtil {
043            /*
044             * NOTE FOR DEVELOPERS:
045             *
046             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
047             */
048    
049            /**
050             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
051             */
052            public static void clearCache() {
053                    getPersistence().clearCache();
054            }
055    
056            /**
057             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
058             */
059            public static void clearCache(AssetTag assetTag) {
060                    getPersistence().clearCache(assetTag);
061            }
062    
063            /**
064             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
065             */
066            public static long countWithDynamicQuery(DynamicQuery dynamicQuery) {
067                    return getPersistence().countWithDynamicQuery(dynamicQuery);
068            }
069    
070            /**
071             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
072             */
073            public static List<AssetTag> findWithDynamicQuery(DynamicQuery dynamicQuery) {
074                    return getPersistence().findWithDynamicQuery(dynamicQuery);
075            }
076    
077            /**
078             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
079             */
080            public static List<AssetTag> findWithDynamicQuery(
081                    DynamicQuery dynamicQuery, int start, int end) {
082                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
083            }
084    
085            /**
086             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
087             */
088            public static List<AssetTag> findWithDynamicQuery(
089                    DynamicQuery dynamicQuery, int start, int end,
090                    OrderByComparator<AssetTag> orderByComparator) {
091                    return getPersistence()
092                                       .findWithDynamicQuery(dynamicQuery, start, end,
093                            orderByComparator);
094            }
095    
096            /**
097             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
098             */
099            public static AssetTag update(AssetTag assetTag) {
100                    return getPersistence().update(assetTag);
101            }
102    
103            /**
104             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
105             */
106            public static AssetTag update(AssetTag assetTag,
107                    ServiceContext serviceContext) {
108                    return getPersistence().update(assetTag, serviceContext);
109            }
110    
111            /**
112            * Returns all the asset tags where uuid = &#63;.
113            *
114            * @param uuid the uuid
115            * @return the matching asset tags
116            */
117            public static List<AssetTag> findByUuid(java.lang.String uuid) {
118                    return getPersistence().findByUuid(uuid);
119            }
120    
121            /**
122            * Returns a range of all the asset tags where uuid = &#63;.
123            *
124            * <p>
125            * 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.
126            * </p>
127            *
128            * @param uuid the uuid
129            * @param start the lower bound of the range of asset tags
130            * @param end the upper bound of the range of asset tags (not inclusive)
131            * @return the range of matching asset tags
132            */
133            public static List<AssetTag> findByUuid(java.lang.String uuid, int start,
134                    int end) {
135                    return getPersistence().findByUuid(uuid, start, end);
136            }
137    
138            /**
139            * Returns an ordered range of all the asset tags where uuid = &#63;.
140            *
141            * <p>
142            * 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.
143            * </p>
144            *
145            * @param uuid the uuid
146            * @param start the lower bound of the range of asset tags
147            * @param end the upper bound of the range of asset tags (not inclusive)
148            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
149            * @return the ordered range of matching asset tags
150            */
151            public static List<AssetTag> findByUuid(java.lang.String uuid, int start,
152                    int end, OrderByComparator<AssetTag> orderByComparator) {
153                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
154            }
155    
156            /**
157            * Returns an ordered range of all the asset tags where uuid = &#63;.
158            *
159            * <p>
160            * 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.
161            * </p>
162            *
163            * @param uuid the uuid
164            * @param start the lower bound of the range of asset tags
165            * @param end the upper bound of the range of asset tags (not inclusive)
166            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
167            * @param retrieveFromCache whether to retrieve from the finder cache
168            * @return the ordered range of matching asset tags
169            */
170            public static List<AssetTag> findByUuid(java.lang.String uuid, int start,
171                    int end, OrderByComparator<AssetTag> orderByComparator,
172                    boolean retrieveFromCache) {
173                    return getPersistence()
174                                       .findByUuid(uuid, start, end, orderByComparator,
175                            retrieveFromCache);
176            }
177    
178            /**
179            * Returns the first asset tag in the ordered set where uuid = &#63;.
180            *
181            * @param uuid the uuid
182            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
183            * @return the first matching asset tag
184            * @throws NoSuchTagException if a matching asset tag could not be found
185            */
186            public static AssetTag findByUuid_First(java.lang.String uuid,
187                    OrderByComparator<AssetTag> orderByComparator)
188                    throws com.liferay.portlet.asset.exception.NoSuchTagException {
189                    return getPersistence().findByUuid_First(uuid, orderByComparator);
190            }
191    
192            /**
193            * Returns the first asset tag in the ordered set where uuid = &#63;.
194            *
195            * @param uuid the uuid
196            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
197            * @return the first matching asset tag, or <code>null</code> if a matching asset tag could not be found
198            */
199            public static AssetTag fetchByUuid_First(java.lang.String uuid,
200                    OrderByComparator<AssetTag> orderByComparator) {
201                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
202            }
203    
204            /**
205            * Returns the last asset tag in the ordered set where uuid = &#63;.
206            *
207            * @param uuid the uuid
208            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
209            * @return the last matching asset tag
210            * @throws NoSuchTagException if a matching asset tag could not be found
211            */
212            public static AssetTag findByUuid_Last(java.lang.String uuid,
213                    OrderByComparator<AssetTag> orderByComparator)
214                    throws com.liferay.portlet.asset.exception.NoSuchTagException {
215                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
216            }
217    
218            /**
219            * Returns the last asset tag in the ordered set where uuid = &#63;.
220            *
221            * @param uuid the uuid
222            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
223            * @return the last matching asset tag, or <code>null</code> if a matching asset tag could not be found
224            */
225            public static AssetTag fetchByUuid_Last(java.lang.String uuid,
226                    OrderByComparator<AssetTag> orderByComparator) {
227                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
228            }
229    
230            /**
231            * Returns the asset tags before and after the current asset tag in the ordered set where uuid = &#63;.
232            *
233            * @param tagId the primary key of the current asset tag
234            * @param uuid the uuid
235            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
236            * @return the previous, current, and next asset tag
237            * @throws NoSuchTagException if a asset tag with the primary key could not be found
238            */
239            public static AssetTag[] findByUuid_PrevAndNext(long tagId,
240                    java.lang.String uuid, OrderByComparator<AssetTag> orderByComparator)
241                    throws com.liferay.portlet.asset.exception.NoSuchTagException {
242                    return getPersistence()
243                                       .findByUuid_PrevAndNext(tagId, uuid, orderByComparator);
244            }
245    
246            /**
247            * Removes all the asset tags where uuid = &#63; from the database.
248            *
249            * @param uuid the uuid
250            */
251            public static void removeByUuid(java.lang.String uuid) {
252                    getPersistence().removeByUuid(uuid);
253            }
254    
255            /**
256            * Returns the number of asset tags where uuid = &#63;.
257            *
258            * @param uuid the uuid
259            * @return the number of matching asset tags
260            */
261            public static int countByUuid(java.lang.String uuid) {
262                    return getPersistence().countByUuid(uuid);
263            }
264    
265            /**
266            * Returns the asset tag where uuid = &#63; and groupId = &#63; or throws a {@link NoSuchTagException} if it could not be found.
267            *
268            * @param uuid the uuid
269            * @param groupId the group ID
270            * @return the matching asset tag
271            * @throws NoSuchTagException if a matching asset tag could not be found
272            */
273            public static AssetTag findByUUID_G(java.lang.String uuid, long groupId)
274                    throws com.liferay.portlet.asset.exception.NoSuchTagException {
275                    return getPersistence().findByUUID_G(uuid, groupId);
276            }
277    
278            /**
279            * 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.
280            *
281            * @param uuid the uuid
282            * @param groupId the group ID
283            * @return the matching asset tag, or <code>null</code> if a matching asset tag could not be found
284            */
285            public static AssetTag fetchByUUID_G(java.lang.String uuid, long groupId) {
286                    return getPersistence().fetchByUUID_G(uuid, groupId);
287            }
288    
289            /**
290            * 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.
291            *
292            * @param uuid the uuid
293            * @param groupId the group ID
294            * @param retrieveFromCache whether to retrieve from the finder cache
295            * @return the matching asset tag, or <code>null</code> if a matching asset tag could not be found
296            */
297            public static AssetTag fetchByUUID_G(java.lang.String uuid, long groupId,
298                    boolean retrieveFromCache) {
299                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
300            }
301    
302            /**
303            * Removes the asset tag where uuid = &#63; and groupId = &#63; from the database.
304            *
305            * @param uuid the uuid
306            * @param groupId the group ID
307            * @return the asset tag that was removed
308            */
309            public static AssetTag removeByUUID_G(java.lang.String uuid, long groupId)
310                    throws com.liferay.portlet.asset.exception.NoSuchTagException {
311                    return getPersistence().removeByUUID_G(uuid, groupId);
312            }
313    
314            /**
315            * Returns the number of asset tags where uuid = &#63; and groupId = &#63;.
316            *
317            * @param uuid the uuid
318            * @param groupId the group ID
319            * @return the number of matching asset tags
320            */
321            public static int countByUUID_G(java.lang.String uuid, long groupId) {
322                    return getPersistence().countByUUID_G(uuid, groupId);
323            }
324    
325            /**
326            * Returns all the asset tags where uuid = &#63; and companyId = &#63;.
327            *
328            * @param uuid the uuid
329            * @param companyId the company ID
330            * @return the matching asset tags
331            */
332            public static List<AssetTag> findByUuid_C(java.lang.String uuid,
333                    long companyId) {
334                    return getPersistence().findByUuid_C(uuid, companyId);
335            }
336    
337            /**
338            * Returns a range of all the asset tags where uuid = &#63; and companyId = &#63;.
339            *
340            * <p>
341            * 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.
342            * </p>
343            *
344            * @param uuid the uuid
345            * @param companyId the company ID
346            * @param start the lower bound of the range of asset tags
347            * @param end the upper bound of the range of asset tags (not inclusive)
348            * @return the range of matching asset tags
349            */
350            public static List<AssetTag> findByUuid_C(java.lang.String uuid,
351                    long companyId, int start, int end) {
352                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
353            }
354    
355            /**
356            * Returns an ordered range of all the asset tags where uuid = &#63; and companyId = &#63;.
357            *
358            * <p>
359            * 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.
360            * </p>
361            *
362            * @param uuid the uuid
363            * @param companyId the company ID
364            * @param start the lower bound of the range of asset tags
365            * @param end the upper bound of the range of asset tags (not inclusive)
366            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
367            * @return the ordered range of matching asset tags
368            */
369            public static List<AssetTag> findByUuid_C(java.lang.String uuid,
370                    long companyId, int start, int end,
371                    OrderByComparator<AssetTag> orderByComparator) {
372                    return getPersistence()
373                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
374            }
375    
376            /**
377            * Returns an ordered range of all the asset tags where uuid = &#63; and companyId = &#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 uuid the uuid
384            * @param companyId the company ID
385            * @param start the lower bound of the range of asset tags
386            * @param end the upper bound of the range of asset tags (not inclusive)
387            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
388            * @param retrieveFromCache whether to retrieve from the finder cache
389            * @return the ordered range of matching asset tags
390            */
391            public static List<AssetTag> findByUuid_C(java.lang.String uuid,
392                    long companyId, int start, int end,
393                    OrderByComparator<AssetTag> orderByComparator, boolean retrieveFromCache) {
394                    return getPersistence()
395                                       .findByUuid_C(uuid, companyId, start, end,
396                            orderByComparator, retrieveFromCache);
397            }
398    
399            /**
400            * Returns the first asset tag in the ordered set where uuid = &#63; and companyId = &#63;.
401            *
402            * @param uuid the uuid
403            * @param companyId the company ID
404            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
405            * @return the first matching asset tag
406            * @throws NoSuchTagException if a matching asset tag could not be found
407            */
408            public static AssetTag findByUuid_C_First(java.lang.String uuid,
409                    long companyId, OrderByComparator<AssetTag> orderByComparator)
410                    throws com.liferay.portlet.asset.exception.NoSuchTagException {
411                    return getPersistence()
412                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
413            }
414    
415            /**
416            * Returns the first asset tag in the ordered set where uuid = &#63; and companyId = &#63;.
417            *
418            * @param uuid the uuid
419            * @param companyId the company ID
420            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
421            * @return the first matching asset tag, or <code>null</code> if a matching asset tag could not be found
422            */
423            public static AssetTag fetchByUuid_C_First(java.lang.String uuid,
424                    long companyId, OrderByComparator<AssetTag> orderByComparator) {
425                    return getPersistence()
426                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
427            }
428    
429            /**
430            * Returns the last asset tag in the ordered set where uuid = &#63; and companyId = &#63;.
431            *
432            * @param uuid the uuid
433            * @param companyId the company ID
434            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
435            * @return the last matching asset tag
436            * @throws NoSuchTagException if a matching asset tag could not be found
437            */
438            public static AssetTag findByUuid_C_Last(java.lang.String uuid,
439                    long companyId, OrderByComparator<AssetTag> orderByComparator)
440                    throws com.liferay.portlet.asset.exception.NoSuchTagException {
441                    return getPersistence()
442                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
443            }
444    
445            /**
446            * Returns the last asset tag in the ordered set where uuid = &#63; and companyId = &#63;.
447            *
448            * @param uuid the uuid
449            * @param companyId the company ID
450            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
451            * @return the last matching asset tag, or <code>null</code> if a matching asset tag could not be found
452            */
453            public static AssetTag fetchByUuid_C_Last(java.lang.String uuid,
454                    long companyId, OrderByComparator<AssetTag> orderByComparator) {
455                    return getPersistence()
456                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
457            }
458    
459            /**
460            * Returns the asset tags before and after the current asset tag in the ordered set where uuid = &#63; and companyId = &#63;.
461            *
462            * @param tagId the primary key of the current asset tag
463            * @param uuid the uuid
464            * @param companyId the company ID
465            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
466            * @return the previous, current, and next asset tag
467            * @throws NoSuchTagException if a asset tag with the primary key could not be found
468            */
469            public static AssetTag[] findByUuid_C_PrevAndNext(long tagId,
470                    java.lang.String uuid, long companyId,
471                    OrderByComparator<AssetTag> orderByComparator)
472                    throws com.liferay.portlet.asset.exception.NoSuchTagException {
473                    return getPersistence()
474                                       .findByUuid_C_PrevAndNext(tagId, uuid, companyId,
475                            orderByComparator);
476            }
477    
478            /**
479            * Removes all the asset tags where uuid = &#63; and companyId = &#63; from the database.
480            *
481            * @param uuid the uuid
482            * @param companyId the company ID
483            */
484            public static void removeByUuid_C(java.lang.String uuid, long companyId) {
485                    getPersistence().removeByUuid_C(uuid, companyId);
486            }
487    
488            /**
489            * Returns the number of asset tags where uuid = &#63; and companyId = &#63;.
490            *
491            * @param uuid the uuid
492            * @param companyId the company ID
493            * @return the number of matching asset tags
494            */
495            public static int countByUuid_C(java.lang.String uuid, long companyId) {
496                    return getPersistence().countByUuid_C(uuid, companyId);
497            }
498    
499            /**
500            * Returns all the asset tags where groupId = &#63;.
501            *
502            * @param groupId the group ID
503            * @return the matching asset tags
504            */
505            public static List<AssetTag> findByGroupId(long groupId) {
506                    return getPersistence().findByGroupId(groupId);
507            }
508    
509            /**
510            * Returns a range of all the asset tags where groupId = &#63;.
511            *
512            * <p>
513            * 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.
514            * </p>
515            *
516            * @param groupId the group ID
517            * @param start the lower bound of the range of asset tags
518            * @param end the upper bound of the range of asset tags (not inclusive)
519            * @return the range of matching asset tags
520            */
521            public static List<AssetTag> findByGroupId(long groupId, int start, int end) {
522                    return getPersistence().findByGroupId(groupId, start, end);
523            }
524    
525            /**
526            * Returns an ordered range of all the asset tags where groupId = &#63;.
527            *
528            * <p>
529            * 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.
530            * </p>
531            *
532            * @param groupId the group ID
533            * @param start the lower bound of the range of asset tags
534            * @param end the upper bound of the range of asset tags (not inclusive)
535            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
536            * @return the ordered range of matching asset tags
537            */
538            public static List<AssetTag> findByGroupId(long groupId, int start,
539                    int end, OrderByComparator<AssetTag> orderByComparator) {
540                    return getPersistence()
541                                       .findByGroupId(groupId, start, end, orderByComparator);
542            }
543    
544            /**
545            * Returns an ordered range of all the asset tags where groupId = &#63;.
546            *
547            * <p>
548            * 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.
549            * </p>
550            *
551            * @param groupId the group ID
552            * @param start the lower bound of the range of asset tags
553            * @param end the upper bound of the range of asset tags (not inclusive)
554            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
555            * @param retrieveFromCache whether to retrieve from the finder cache
556            * @return the ordered range of matching asset tags
557            */
558            public static List<AssetTag> findByGroupId(long groupId, int start,
559                    int end, OrderByComparator<AssetTag> orderByComparator,
560                    boolean retrieveFromCache) {
561                    return getPersistence()
562                                       .findByGroupId(groupId, start, end, orderByComparator,
563                            retrieveFromCache);
564            }
565    
566            /**
567            * Returns the first asset tag in the ordered set where groupId = &#63;.
568            *
569            * @param groupId the group ID
570            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
571            * @return the first matching asset tag
572            * @throws NoSuchTagException if a matching asset tag could not be found
573            */
574            public static AssetTag findByGroupId_First(long groupId,
575                    OrderByComparator<AssetTag> orderByComparator)
576                    throws com.liferay.portlet.asset.exception.NoSuchTagException {
577                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
578            }
579    
580            /**
581            * Returns the first asset tag in the ordered set where groupId = &#63;.
582            *
583            * @param groupId the group ID
584            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
585            * @return the first matching asset tag, or <code>null</code> if a matching asset tag could not be found
586            */
587            public static AssetTag fetchByGroupId_First(long groupId,
588                    OrderByComparator<AssetTag> orderByComparator) {
589                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
590            }
591    
592            /**
593            * Returns the last asset tag in the ordered set where groupId = &#63;.
594            *
595            * @param groupId the group ID
596            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
597            * @return the last matching asset tag
598            * @throws NoSuchTagException if a matching asset tag could not be found
599            */
600            public static AssetTag findByGroupId_Last(long groupId,
601                    OrderByComparator<AssetTag> orderByComparator)
602                    throws com.liferay.portlet.asset.exception.NoSuchTagException {
603                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
604            }
605    
606            /**
607            * Returns the last asset tag in the ordered set where groupId = &#63;.
608            *
609            * @param groupId the group ID
610            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
611            * @return the last matching asset tag, or <code>null</code> if a matching asset tag could not be found
612            */
613            public static AssetTag fetchByGroupId_Last(long groupId,
614                    OrderByComparator<AssetTag> orderByComparator) {
615                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
616            }
617    
618            /**
619            * Returns the asset tags before and after the current asset tag in the ordered set where groupId = &#63;.
620            *
621            * @param tagId the primary key of the current asset tag
622            * @param groupId the group ID
623            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
624            * @return the previous, current, and next asset tag
625            * @throws NoSuchTagException if a asset tag with the primary key could not be found
626            */
627            public static AssetTag[] findByGroupId_PrevAndNext(long tagId,
628                    long groupId, OrderByComparator<AssetTag> orderByComparator)
629                    throws com.liferay.portlet.asset.exception.NoSuchTagException {
630                    return getPersistence()
631                                       .findByGroupId_PrevAndNext(tagId, groupId, orderByComparator);
632            }
633    
634            /**
635            * Returns all the asset tags that the user has permission to view where groupId = &#63;.
636            *
637            * @param groupId the group ID
638            * @return the matching asset tags that the user has permission to view
639            */
640            public static List<AssetTag> filterFindByGroupId(long groupId) {
641                    return getPersistence().filterFindByGroupId(groupId);
642            }
643    
644            /**
645            * Returns a range of all the asset tags that the user has permission to view where groupId = &#63;.
646            *
647            * <p>
648            * 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.
649            * </p>
650            *
651            * @param groupId the group ID
652            * @param start the lower bound of the range of asset tags
653            * @param end the upper bound of the range of asset tags (not inclusive)
654            * @return the range of matching asset tags that the user has permission to view
655            */
656            public static List<AssetTag> filterFindByGroupId(long groupId, int start,
657                    int end) {
658                    return getPersistence().filterFindByGroupId(groupId, start, end);
659            }
660    
661            /**
662            * Returns an ordered range of all the asset tags that the user has permissions to view where groupId = &#63;.
663            *
664            * <p>
665            * 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.
666            * </p>
667            *
668            * @param groupId the group ID
669            * @param start the lower bound of the range of asset tags
670            * @param end the upper bound of the range of asset tags (not inclusive)
671            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
672            * @return the ordered range of matching asset tags that the user has permission to view
673            */
674            public static List<AssetTag> filterFindByGroupId(long groupId, int start,
675                    int end, OrderByComparator<AssetTag> orderByComparator) {
676                    return getPersistence()
677                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
678            }
679    
680            /**
681            * 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;.
682            *
683            * @param tagId the primary key of the current asset tag
684            * @param groupId the group ID
685            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
686            * @return the previous, current, and next asset tag
687            * @throws NoSuchTagException if a asset tag with the primary key could not be found
688            */
689            public static AssetTag[] filterFindByGroupId_PrevAndNext(long tagId,
690                    long groupId, OrderByComparator<AssetTag> orderByComparator)
691                    throws com.liferay.portlet.asset.exception.NoSuchTagException {
692                    return getPersistence()
693                                       .filterFindByGroupId_PrevAndNext(tagId, groupId,
694                            orderByComparator);
695            }
696    
697            /**
698            * Returns all the asset tags that the user has permission to view where groupId = any &#63;.
699            *
700            * @param groupIds the group IDs
701            * @return the matching asset tags that the user has permission to view
702            */
703            public static List<AssetTag> filterFindByGroupId(long[] groupIds) {
704                    return getPersistence().filterFindByGroupId(groupIds);
705            }
706    
707            /**
708            * Returns a range of all the asset tags that the user has permission to view where groupId = any &#63;.
709            *
710            * <p>
711            * 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.
712            * </p>
713            *
714            * @param groupIds the group IDs
715            * @param start the lower bound of the range of asset tags
716            * @param end the upper bound of the range of asset tags (not inclusive)
717            * @return the range of matching asset tags that the user has permission to view
718            */
719            public static List<AssetTag> filterFindByGroupId(long[] groupIds,
720                    int start, int end) {
721                    return getPersistence().filterFindByGroupId(groupIds, start, end);
722            }
723    
724            /**
725            * Returns an ordered range of all the asset tags that the user has permission to view where groupId = any &#63;.
726            *
727            * <p>
728            * 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.
729            * </p>
730            *
731            * @param groupIds the group IDs
732            * @param start the lower bound of the range of asset tags
733            * @param end the upper bound of the range of asset tags (not inclusive)
734            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
735            * @return the ordered range of matching asset tags that the user has permission to view
736            */
737            public static List<AssetTag> filterFindByGroupId(long[] groupIds,
738                    int start, int end, OrderByComparator<AssetTag> orderByComparator) {
739                    return getPersistence()
740                                       .filterFindByGroupId(groupIds, start, end, orderByComparator);
741            }
742    
743            /**
744            * Returns all the asset tags where groupId = any &#63;.
745            *
746            * <p>
747            * 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.
748            * </p>
749            *
750            * @param groupIds the group IDs
751            * @return the matching asset tags
752            */
753            public static List<AssetTag> findByGroupId(long[] groupIds) {
754                    return getPersistence().findByGroupId(groupIds);
755            }
756    
757            /**
758            * Returns a range of all the asset tags where groupId = any &#63;.
759            *
760            * <p>
761            * 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.
762            * </p>
763            *
764            * @param groupIds the group IDs
765            * @param start the lower bound of the range of asset tags
766            * @param end the upper bound of the range of asset tags (not inclusive)
767            * @return the range of matching asset tags
768            */
769            public static List<AssetTag> findByGroupId(long[] groupIds, int start,
770                    int end) {
771                    return getPersistence().findByGroupId(groupIds, start, end);
772            }
773    
774            /**
775            * Returns an ordered range of all the asset tags where groupId = any &#63;.
776            *
777            * <p>
778            * 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.
779            * </p>
780            *
781            * @param groupIds the group IDs
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            * @return the ordered range of matching asset tags
786            */
787            public static List<AssetTag> findByGroupId(long[] groupIds, int start,
788                    int end, OrderByComparator<AssetTag> orderByComparator) {
789                    return getPersistence()
790                                       .findByGroupId(groupIds, start, end, orderByComparator);
791            }
792    
793            /**
794            * Returns an ordered range of all the asset tags where groupId = &#63;, optionally using the finder cache.
795            *
796            * <p>
797            * 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.
798            * </p>
799            *
800            * @param groupId the group ID
801            * @param start the lower bound of the range of asset tags
802            * @param end the upper bound of the range of asset tags (not inclusive)
803            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
804            * @param retrieveFromCache whether to retrieve from the finder cache
805            * @return the ordered range of matching asset tags
806            */
807            public static List<AssetTag> findByGroupId(long[] groupIds, int start,
808                    int end, OrderByComparator<AssetTag> orderByComparator,
809                    boolean retrieveFromCache) {
810                    return getPersistence()
811                                       .findByGroupId(groupIds, start, end, orderByComparator,
812                            retrieveFromCache);
813            }
814    
815            /**
816            * Removes all the asset tags where groupId = &#63; from the database.
817            *
818            * @param groupId the group ID
819            */
820            public static void removeByGroupId(long groupId) {
821                    getPersistence().removeByGroupId(groupId);
822            }
823    
824            /**
825            * Returns the number of asset tags where groupId = &#63;.
826            *
827            * @param groupId the group ID
828            * @return the number of matching asset tags
829            */
830            public static int countByGroupId(long groupId) {
831                    return getPersistence().countByGroupId(groupId);
832            }
833    
834            /**
835            * Returns the number of asset tags where groupId = any &#63;.
836            *
837            * @param groupIds the group IDs
838            * @return the number of matching asset tags
839            */
840            public static int countByGroupId(long[] groupIds) {
841                    return getPersistence().countByGroupId(groupIds);
842            }
843    
844            /**
845            * Returns the number of asset tags that the user has permission to view where groupId = &#63;.
846            *
847            * @param groupId the group ID
848            * @return the number of matching asset tags that the user has permission to view
849            */
850            public static int filterCountByGroupId(long groupId) {
851                    return getPersistence().filterCountByGroupId(groupId);
852            }
853    
854            /**
855            * Returns the number of asset tags that the user has permission to view where groupId = any &#63;.
856            *
857            * @param groupIds the group IDs
858            * @return the number of matching asset tags that the user has permission to view
859            */
860            public static int filterCountByGroupId(long[] groupIds) {
861                    return getPersistence().filterCountByGroupId(groupIds);
862            }
863    
864            /**
865            * Returns the asset tag where groupId = &#63; and name = &#63; or throws a {@link NoSuchTagException} if it could not be found.
866            *
867            * @param groupId the group ID
868            * @param name the name
869            * @return the matching asset tag
870            * @throws NoSuchTagException if a matching asset tag could not be found
871            */
872            public static AssetTag findByG_N(long groupId, java.lang.String name)
873                    throws com.liferay.portlet.asset.exception.NoSuchTagException {
874                    return getPersistence().findByG_N(groupId, name);
875            }
876    
877            /**
878            * 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.
879            *
880            * @param groupId the group ID
881            * @param name the name
882            * @return the matching asset tag, or <code>null</code> if a matching asset tag could not be found
883            */
884            public static AssetTag fetchByG_N(long groupId, java.lang.String name) {
885                    return getPersistence().fetchByG_N(groupId, name);
886            }
887    
888            /**
889            * 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.
890            *
891            * @param groupId the group ID
892            * @param name the name
893            * @param retrieveFromCache whether to retrieve from the finder cache
894            * @return the matching asset tag, or <code>null</code> if a matching asset tag could not be found
895            */
896            public static AssetTag fetchByG_N(long groupId, java.lang.String name,
897                    boolean retrieveFromCache) {
898                    return getPersistence().fetchByG_N(groupId, name, retrieveFromCache);
899            }
900    
901            /**
902            * Removes the asset tag where groupId = &#63; and name = &#63; from the database.
903            *
904            * @param groupId the group ID
905            * @param name the name
906            * @return the asset tag that was removed
907            */
908            public static AssetTag removeByG_N(long groupId, java.lang.String name)
909                    throws com.liferay.portlet.asset.exception.NoSuchTagException {
910                    return getPersistence().removeByG_N(groupId, name);
911            }
912    
913            /**
914            * Returns the number of asset tags where groupId = &#63; and name = &#63;.
915            *
916            * @param groupId the group ID
917            * @param name the name
918            * @return the number of matching asset tags
919            */
920            public static int countByG_N(long groupId, java.lang.String name) {
921                    return getPersistence().countByG_N(groupId, name);
922            }
923    
924            /**
925            * Returns all the asset tags where groupId = &#63; and name LIKE &#63;.
926            *
927            * @param groupId the group ID
928            * @param name the name
929            * @return the matching asset tags
930            */
931            public static List<AssetTag> findByG_LikeN(long groupId,
932                    java.lang.String name) {
933                    return getPersistence().findByG_LikeN(groupId, name);
934            }
935    
936            /**
937            * Returns a range of all the asset tags where groupId = &#63; and name LIKE &#63;.
938            *
939            * <p>
940            * 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.
941            * </p>
942            *
943            * @param groupId the group ID
944            * @param name the name
945            * @param start the lower bound of the range of asset tags
946            * @param end the upper bound of the range of asset tags (not inclusive)
947            * @return the range of matching asset tags
948            */
949            public static List<AssetTag> findByG_LikeN(long groupId,
950                    java.lang.String name, int start, int end) {
951                    return getPersistence().findByG_LikeN(groupId, name, start, end);
952            }
953    
954            /**
955            * Returns an ordered range of all the asset tags where groupId = &#63; and name LIKE &#63;.
956            *
957            * <p>
958            * 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.
959            * </p>
960            *
961            * @param groupId the group ID
962            * @param name the name
963            * @param start the lower bound of the range of asset tags
964            * @param end the upper bound of the range of asset tags (not inclusive)
965            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
966            * @return the ordered range of matching asset tags
967            */
968            public static List<AssetTag> findByG_LikeN(long groupId,
969                    java.lang.String name, int start, int end,
970                    OrderByComparator<AssetTag> orderByComparator) {
971                    return getPersistence()
972                                       .findByG_LikeN(groupId, name, start, end, orderByComparator);
973            }
974    
975            /**
976            * Returns an ordered range of all the asset tags where groupId = &#63; and name LIKE &#63;.
977            *
978            * <p>
979            * 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.
980            * </p>
981            *
982            * @param groupId the group ID
983            * @param name the name
984            * @param start the lower bound of the range of asset tags
985            * @param end the upper bound of the range of asset tags (not inclusive)
986            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
987            * @param retrieveFromCache whether to retrieve from the finder cache
988            * @return the ordered range of matching asset tags
989            */
990            public static List<AssetTag> findByG_LikeN(long groupId,
991                    java.lang.String name, int start, int end,
992                    OrderByComparator<AssetTag> orderByComparator, boolean retrieveFromCache) {
993                    return getPersistence()
994                                       .findByG_LikeN(groupId, name, start, end, orderByComparator,
995                            retrieveFromCache);
996            }
997    
998            /**
999            * Returns the first asset tag in the ordered set where groupId = &#63; and name LIKE &#63;.
1000            *
1001            * @param groupId the group ID
1002            * @param name the name
1003            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1004            * @return the first matching asset tag
1005            * @throws NoSuchTagException if a matching asset tag could not be found
1006            */
1007            public static AssetTag findByG_LikeN_First(long groupId,
1008                    java.lang.String name, OrderByComparator<AssetTag> orderByComparator)
1009                    throws com.liferay.portlet.asset.exception.NoSuchTagException {
1010                    return getPersistence()
1011                                       .findByG_LikeN_First(groupId, name, orderByComparator);
1012            }
1013    
1014            /**
1015            * Returns the first asset tag in the ordered set where groupId = &#63; and name LIKE &#63;.
1016            *
1017            * @param groupId the group ID
1018            * @param name the name
1019            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1020            * @return the first matching asset tag, or <code>null</code> if a matching asset tag could not be found
1021            */
1022            public static AssetTag fetchByG_LikeN_First(long groupId,
1023                    java.lang.String name, OrderByComparator<AssetTag> orderByComparator) {
1024                    return getPersistence()
1025                                       .fetchByG_LikeN_First(groupId, name, orderByComparator);
1026            }
1027    
1028            /**
1029            * Returns the last asset tag in the ordered set where groupId = &#63; and name LIKE &#63;.
1030            *
1031            * @param groupId the group ID
1032            * @param name the name
1033            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1034            * @return the last matching asset tag
1035            * @throws NoSuchTagException if a matching asset tag could not be found
1036            */
1037            public static AssetTag findByG_LikeN_Last(long groupId,
1038                    java.lang.String name, OrderByComparator<AssetTag> orderByComparator)
1039                    throws com.liferay.portlet.asset.exception.NoSuchTagException {
1040                    return getPersistence()
1041                                       .findByG_LikeN_Last(groupId, name, orderByComparator);
1042            }
1043    
1044            /**
1045            * Returns the last asset tag in the ordered set where groupId = &#63; and name LIKE &#63;.
1046            *
1047            * @param groupId the group ID
1048            * @param name the name
1049            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1050            * @return the last matching asset tag, or <code>null</code> if a matching asset tag could not be found
1051            */
1052            public static AssetTag fetchByG_LikeN_Last(long groupId,
1053                    java.lang.String name, OrderByComparator<AssetTag> orderByComparator) {
1054                    return getPersistence()
1055                                       .fetchByG_LikeN_Last(groupId, name, orderByComparator);
1056            }
1057    
1058            /**
1059            * Returns the asset tags before and after the current asset tag in the ordered set where groupId = &#63; and name LIKE &#63;.
1060            *
1061            * @param tagId the primary key of the current asset tag
1062            * @param groupId the group ID
1063            * @param name the name
1064            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1065            * @return the previous, current, and next asset tag
1066            * @throws NoSuchTagException if a asset tag with the primary key could not be found
1067            */
1068            public static AssetTag[] findByG_LikeN_PrevAndNext(long tagId,
1069                    long groupId, java.lang.String name,
1070                    OrderByComparator<AssetTag> orderByComparator)
1071                    throws com.liferay.portlet.asset.exception.NoSuchTagException {
1072                    return getPersistence()
1073                                       .findByG_LikeN_PrevAndNext(tagId, groupId, name,
1074                            orderByComparator);
1075            }
1076    
1077            /**
1078            * Returns all the asset tags that the user has permission to view where groupId = &#63; and name LIKE &#63;.
1079            *
1080            * @param groupId the group ID
1081            * @param name the name
1082            * @return the matching asset tags that the user has permission to view
1083            */
1084            public static List<AssetTag> filterFindByG_LikeN(long groupId,
1085                    java.lang.String name) {
1086                    return getPersistence().filterFindByG_LikeN(groupId, name);
1087            }
1088    
1089            /**
1090            * Returns a range of all the asset tags that the user has permission to view where groupId = &#63; and name LIKE &#63;.
1091            *
1092            * <p>
1093            * 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.
1094            * </p>
1095            *
1096            * @param groupId the group ID
1097            * @param name the name
1098            * @param start the lower bound of the range of asset tags
1099            * @param end the upper bound of the range of asset tags (not inclusive)
1100            * @return the range of matching asset tags that the user has permission to view
1101            */
1102            public static List<AssetTag> filterFindByG_LikeN(long groupId,
1103                    java.lang.String name, int start, int end) {
1104                    return getPersistence().filterFindByG_LikeN(groupId, name, start, end);
1105            }
1106    
1107            /**
1108            * Returns an ordered range of all the asset tags that the user has permissions to view where groupId = &#63; and name LIKE &#63;.
1109            *
1110            * <p>
1111            * 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.
1112            * </p>
1113            *
1114            * @param groupId the group ID
1115            * @param name the name
1116            * @param start the lower bound of the range of asset tags
1117            * @param end the upper bound of the range of asset tags (not inclusive)
1118            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1119            * @return the ordered range of matching asset tags that the user has permission to view
1120            */
1121            public static List<AssetTag> filterFindByG_LikeN(long groupId,
1122                    java.lang.String name, int start, int end,
1123                    OrderByComparator<AssetTag> orderByComparator) {
1124                    return getPersistence()
1125                                       .filterFindByG_LikeN(groupId, name, start, end,
1126                            orderByComparator);
1127            }
1128    
1129            /**
1130            * 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;.
1131            *
1132            * @param tagId the primary key of the current asset tag
1133            * @param groupId the group ID
1134            * @param name the name
1135            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1136            * @return the previous, current, and next asset tag
1137            * @throws NoSuchTagException if a asset tag with the primary key could not be found
1138            */
1139            public static AssetTag[] filterFindByG_LikeN_PrevAndNext(long tagId,
1140                    long groupId, java.lang.String name,
1141                    OrderByComparator<AssetTag> orderByComparator)
1142                    throws com.liferay.portlet.asset.exception.NoSuchTagException {
1143                    return getPersistence()
1144                                       .filterFindByG_LikeN_PrevAndNext(tagId, groupId, name,
1145                            orderByComparator);
1146            }
1147    
1148            /**
1149            * Returns all the asset tags that the user has permission to view where groupId = any &#63; and name LIKE &#63;.
1150            *
1151            * @param groupIds the group IDs
1152            * @param name the name
1153            * @return the matching asset tags that the user has permission to view
1154            */
1155            public static List<AssetTag> filterFindByG_LikeN(long[] groupIds,
1156                    java.lang.String name) {
1157                    return getPersistence().filterFindByG_LikeN(groupIds, name);
1158            }
1159    
1160            /**
1161            * Returns a range of all the asset tags that the user has permission to view where groupId = any &#63; and name LIKE &#63;.
1162            *
1163            * <p>
1164            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1165            * </p>
1166            *
1167            * @param groupIds the group IDs
1168            * @param name the name
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            * @return the range of matching asset tags that the user has permission to view
1172            */
1173            public static List<AssetTag> filterFindByG_LikeN(long[] groupIds,
1174                    java.lang.String name, int start, int end) {
1175                    return getPersistence().filterFindByG_LikeN(groupIds, name, start, end);
1176            }
1177    
1178            /**
1179            * Returns an ordered range of all the asset tags that the user has permission to view where groupId = any &#63; and name LIKE &#63;.
1180            *
1181            * <p>
1182            * 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.
1183            * </p>
1184            *
1185            * @param groupIds the group IDs
1186            * @param name the name
1187            * @param start the lower bound of the range of asset tags
1188            * @param end the upper bound of the range of asset tags (not inclusive)
1189            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1190            * @return the ordered range of matching asset tags that the user has permission to view
1191            */
1192            public static List<AssetTag> filterFindByG_LikeN(long[] groupIds,
1193                    java.lang.String name, int start, int end,
1194                    OrderByComparator<AssetTag> orderByComparator) {
1195                    return getPersistence()
1196                                       .filterFindByG_LikeN(groupIds, name, start, end,
1197                            orderByComparator);
1198            }
1199    
1200            /**
1201            * Returns all the asset tags where groupId = any &#63; and name LIKE &#63;.
1202            *
1203            * <p>
1204            * 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.
1205            * </p>
1206            *
1207            * @param groupIds the group IDs
1208            * @param name the name
1209            * @return the matching asset tags
1210            */
1211            public static List<AssetTag> findByG_LikeN(long[] groupIds,
1212                    java.lang.String name) {
1213                    return getPersistence().findByG_LikeN(groupIds, name);
1214            }
1215    
1216            /**
1217            * Returns a range of all the asset tags where groupId = any &#63; and name LIKE &#63;.
1218            *
1219            * <p>
1220            * 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.
1221            * </p>
1222            *
1223            * @param groupIds the group IDs
1224            * @param name the name
1225            * @param start the lower bound of the range of asset tags
1226            * @param end the upper bound of the range of asset tags (not inclusive)
1227            * @return the range of matching asset tags
1228            */
1229            public static List<AssetTag> findByG_LikeN(long[] groupIds,
1230                    java.lang.String name, int start, int end) {
1231                    return getPersistence().findByG_LikeN(groupIds, name, start, end);
1232            }
1233    
1234            /**
1235            * Returns an ordered range of all the asset tags where groupId = any &#63; and name LIKE &#63;.
1236            *
1237            * <p>
1238            * 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.
1239            * </p>
1240            *
1241            * @param groupIds the group IDs
1242            * @param name the name
1243            * @param start the lower bound of the range of asset tags
1244            * @param end the upper bound of the range of asset tags (not inclusive)
1245            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1246            * @return the ordered range of matching asset tags
1247            */
1248            public static List<AssetTag> findByG_LikeN(long[] groupIds,
1249                    java.lang.String name, int start, int end,
1250                    OrderByComparator<AssetTag> orderByComparator) {
1251                    return getPersistence()
1252                                       .findByG_LikeN(groupIds, name, start, end, orderByComparator);
1253            }
1254    
1255            /**
1256            * Returns an ordered range of all the asset tags where groupId = &#63; and name LIKE &#63;, optionally using the finder cache.
1257            *
1258            * <p>
1259            * 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.
1260            * </p>
1261            *
1262            * @param groupId the group ID
1263            * @param name the name
1264            * @param start the lower bound of the range of asset tags
1265            * @param end the upper bound of the range of asset tags (not inclusive)
1266            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1267            * @param retrieveFromCache whether to retrieve from the finder cache
1268            * @return the ordered range of matching asset tags
1269            */
1270            public static List<AssetTag> findByG_LikeN(long[] groupIds,
1271                    java.lang.String name, int start, int end,
1272                    OrderByComparator<AssetTag> orderByComparator, boolean retrieveFromCache) {
1273                    return getPersistence()
1274                                       .findByG_LikeN(groupIds, name, start, end,
1275                            orderByComparator, retrieveFromCache);
1276            }
1277    
1278            /**
1279            * Removes all the asset tags where groupId = &#63; and name LIKE &#63; from the database.
1280            *
1281            * @param groupId the group ID
1282            * @param name the name
1283            */
1284            public static void removeByG_LikeN(long groupId, java.lang.String name) {
1285                    getPersistence().removeByG_LikeN(groupId, name);
1286            }
1287    
1288            /**
1289            * Returns the number of asset tags where groupId = &#63; and name LIKE &#63;.
1290            *
1291            * @param groupId the group ID
1292            * @param name the name
1293            * @return the number of matching asset tags
1294            */
1295            public static int countByG_LikeN(long groupId, java.lang.String name) {
1296                    return getPersistence().countByG_LikeN(groupId, name);
1297            }
1298    
1299            /**
1300            * Returns the number of asset tags where groupId = any &#63; and name LIKE &#63;.
1301            *
1302            * @param groupIds the group IDs
1303            * @param name the name
1304            * @return the number of matching asset tags
1305            */
1306            public static int countByG_LikeN(long[] groupIds, java.lang.String name) {
1307                    return getPersistence().countByG_LikeN(groupIds, name);
1308            }
1309    
1310            /**
1311            * Returns the number of asset tags that the user has permission to view where groupId = &#63; and name LIKE &#63;.
1312            *
1313            * @param groupId the group ID
1314            * @param name the name
1315            * @return the number of matching asset tags that the user has permission to view
1316            */
1317            public static int filterCountByG_LikeN(long groupId, java.lang.String name) {
1318                    return getPersistence().filterCountByG_LikeN(groupId, name);
1319            }
1320    
1321            /**
1322            * Returns the number of asset tags that the user has permission to view where groupId = any &#63; and name LIKE &#63;.
1323            *
1324            * @param groupIds the group IDs
1325            * @param name the name
1326            * @return the number of matching asset tags that the user has permission to view
1327            */
1328            public static int filterCountByG_LikeN(long[] groupIds,
1329                    java.lang.String name) {
1330                    return getPersistence().filterCountByG_LikeN(groupIds, name);
1331            }
1332    
1333            /**
1334            * Caches the asset tag in the entity cache if it is enabled.
1335            *
1336            * @param assetTag the asset tag
1337            */
1338            public static void cacheResult(AssetTag assetTag) {
1339                    getPersistence().cacheResult(assetTag);
1340            }
1341    
1342            /**
1343            * Caches the asset tags in the entity cache if it is enabled.
1344            *
1345            * @param assetTags the asset tags
1346            */
1347            public static void cacheResult(List<AssetTag> assetTags) {
1348                    getPersistence().cacheResult(assetTags);
1349            }
1350    
1351            /**
1352            * Creates a new asset tag with the primary key. Does not add the asset tag to the database.
1353            *
1354            * @param tagId the primary key for the new asset tag
1355            * @return the new asset tag
1356            */
1357            public static AssetTag create(long tagId) {
1358                    return getPersistence().create(tagId);
1359            }
1360    
1361            /**
1362            * Removes the asset tag with the primary key from the database. Also notifies the appropriate model listeners.
1363            *
1364            * @param tagId the primary key of the asset tag
1365            * @return the asset tag that was removed
1366            * @throws NoSuchTagException if a asset tag with the primary key could not be found
1367            */
1368            public static AssetTag remove(long tagId)
1369                    throws com.liferay.portlet.asset.exception.NoSuchTagException {
1370                    return getPersistence().remove(tagId);
1371            }
1372    
1373            public static AssetTag updateImpl(AssetTag assetTag) {
1374                    return getPersistence().updateImpl(assetTag);
1375            }
1376    
1377            /**
1378            * Returns the asset tag with the primary key or throws a {@link NoSuchTagException} if it could not be found.
1379            *
1380            * @param tagId the primary key of the asset tag
1381            * @return the asset tag
1382            * @throws NoSuchTagException if a asset tag with the primary key could not be found
1383            */
1384            public static AssetTag findByPrimaryKey(long tagId)
1385                    throws com.liferay.portlet.asset.exception.NoSuchTagException {
1386                    return getPersistence().findByPrimaryKey(tagId);
1387            }
1388    
1389            /**
1390            * Returns the asset tag with the primary key or returns <code>null</code> if it could not be found.
1391            *
1392            * @param tagId the primary key of the asset tag
1393            * @return the asset tag, or <code>null</code> if a asset tag with the primary key could not be found
1394            */
1395            public static AssetTag fetchByPrimaryKey(long tagId) {
1396                    return getPersistence().fetchByPrimaryKey(tagId);
1397            }
1398    
1399            public static java.util.Map<java.io.Serializable, AssetTag> fetchByPrimaryKeys(
1400                    java.util.Set<java.io.Serializable> primaryKeys) {
1401                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
1402            }
1403    
1404            /**
1405            * Returns all the asset tags.
1406            *
1407            * @return the asset tags
1408            */
1409            public static List<AssetTag> findAll() {
1410                    return getPersistence().findAll();
1411            }
1412    
1413            /**
1414            * Returns a range of all the asset tags.
1415            *
1416            * <p>
1417            * 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.
1418            * </p>
1419            *
1420            * @param start the lower bound of the range of asset tags
1421            * @param end the upper bound of the range of asset tags (not inclusive)
1422            * @return the range of asset tags
1423            */
1424            public static List<AssetTag> findAll(int start, int end) {
1425                    return getPersistence().findAll(start, end);
1426            }
1427    
1428            /**
1429            * Returns an ordered range of all the asset tags.
1430            *
1431            * <p>
1432            * 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.
1433            * </p>
1434            *
1435            * @param start the lower bound of the range of asset tags
1436            * @param end the upper bound of the range of asset tags (not inclusive)
1437            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1438            * @return the ordered range of asset tags
1439            */
1440            public static List<AssetTag> findAll(int start, int end,
1441                    OrderByComparator<AssetTag> orderByComparator) {
1442                    return getPersistence().findAll(start, end, orderByComparator);
1443            }
1444    
1445            /**
1446            * Returns an ordered range of all the asset tags.
1447            *
1448            * <p>
1449            * 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.
1450            * </p>
1451            *
1452            * @param start the lower bound of the range of asset tags
1453            * @param end the upper bound of the range of asset tags (not inclusive)
1454            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1455            * @param retrieveFromCache whether to retrieve from the finder cache
1456            * @return the ordered range of asset tags
1457            */
1458            public static List<AssetTag> findAll(int start, int end,
1459                    OrderByComparator<AssetTag> orderByComparator, boolean retrieveFromCache) {
1460                    return getPersistence()
1461                                       .findAll(start, end, orderByComparator, retrieveFromCache);
1462            }
1463    
1464            /**
1465            * Removes all the asset tags from the database.
1466            */
1467            public static void removeAll() {
1468                    getPersistence().removeAll();
1469            }
1470    
1471            /**
1472            * Returns the number of asset tags.
1473            *
1474            * @return the number of asset tags
1475            */
1476            public static int countAll() {
1477                    return getPersistence().countAll();
1478            }
1479    
1480            /**
1481            * Returns the primaryKeys of asset entries associated with the asset tag.
1482            *
1483            * @param pk the primary key of the asset tag
1484            * @return long[] of the primaryKeys of asset entries associated with the asset tag
1485            */
1486            public static long[] getAssetEntryPrimaryKeys(long pk) {
1487                    return getPersistence().getAssetEntryPrimaryKeys(pk);
1488            }
1489    
1490            /**
1491            * Returns all the asset entries associated with the asset tag.
1492            *
1493            * @param pk the primary key of the asset tag
1494            * @return the asset entries associated with the asset tag
1495            */
1496            public static List<com.liferay.portlet.asset.model.AssetEntry> getAssetEntries(
1497                    long pk) {
1498                    return getPersistence().getAssetEntries(pk);
1499            }
1500    
1501            /**
1502            * Returns a range of all the asset entries associated with the asset tag.
1503            *
1504            * <p>
1505            * 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.
1506            * </p>
1507            *
1508            * @param pk the primary key of the asset tag
1509            * @param start the lower bound of the range of asset tags
1510            * @param end the upper bound of the range of asset tags (not inclusive)
1511            * @return the range of asset entries associated with the asset tag
1512            */
1513            public static List<com.liferay.portlet.asset.model.AssetEntry> getAssetEntries(
1514                    long pk, int start, int end) {
1515                    return getPersistence().getAssetEntries(pk, start, end);
1516            }
1517    
1518            /**
1519            * Returns an ordered range of all the asset entries associated with the asset tag.
1520            *
1521            * <p>
1522            * 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.
1523            * </p>
1524            *
1525            * @param pk the primary key of the asset tag
1526            * @param start the lower bound of the range of asset tags
1527            * @param end the upper bound of the range of asset tags (not inclusive)
1528            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1529            * @return the ordered range of asset entries associated with the asset tag
1530            */
1531            public static List<com.liferay.portlet.asset.model.AssetEntry> getAssetEntries(
1532                    long pk, int start, int end,
1533                    OrderByComparator<com.liferay.portlet.asset.model.AssetEntry> orderByComparator) {
1534                    return getPersistence()
1535                                       .getAssetEntries(pk, start, end, orderByComparator);
1536            }
1537    
1538            /**
1539            * Returns the number of asset entries associated with the asset tag.
1540            *
1541            * @param pk the primary key of the asset tag
1542            * @return the number of asset entries associated with the asset tag
1543            */
1544            public static int getAssetEntriesSize(long pk) {
1545                    return getPersistence().getAssetEntriesSize(pk);
1546            }
1547    
1548            /**
1549            * Returns <code>true</code> if the asset entry is associated with the asset tag.
1550            *
1551            * @param pk the primary key of the asset tag
1552            * @param assetEntryPK the primary key of the asset entry
1553            * @return <code>true</code> if the asset entry is associated with the asset tag; <code>false</code> otherwise
1554            */
1555            public static boolean containsAssetEntry(long pk, long assetEntryPK) {
1556                    return getPersistence().containsAssetEntry(pk, assetEntryPK);
1557            }
1558    
1559            /**
1560            * Returns <code>true</code> if the asset tag has any asset entries associated with it.
1561            *
1562            * @param pk the primary key of the asset tag to check for associations with asset entries
1563            * @return <code>true</code> if the asset tag has any asset entries associated with it; <code>false</code> otherwise
1564            */
1565            public static boolean containsAssetEntries(long pk) {
1566                    return getPersistence().containsAssetEntries(pk);
1567            }
1568    
1569            /**
1570            * Adds an association between the asset tag and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1571            *
1572            * @param pk the primary key of the asset tag
1573            * @param assetEntryPK the primary key of the asset entry
1574            */
1575            public static void addAssetEntry(long pk, long assetEntryPK) {
1576                    getPersistence().addAssetEntry(pk, assetEntryPK);
1577            }
1578    
1579            /**
1580            * Adds an association between the asset tag and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1581            *
1582            * @param pk the primary key of the asset tag
1583            * @param assetEntry the asset entry
1584            */
1585            public static void addAssetEntry(long pk,
1586                    com.liferay.portlet.asset.model.AssetEntry assetEntry) {
1587                    getPersistence().addAssetEntry(pk, assetEntry);
1588            }
1589    
1590            /**
1591            * Adds an association between the asset tag and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1592            *
1593            * @param pk the primary key of the asset tag
1594            * @param assetEntryPKs the primary keys of the asset entries
1595            */
1596            public static void addAssetEntries(long pk, long[] assetEntryPKs) {
1597                    getPersistence().addAssetEntries(pk, assetEntryPKs);
1598            }
1599    
1600            /**
1601            * Adds an association between the asset tag and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1602            *
1603            * @param pk the primary key of the asset tag
1604            * @param assetEntries the asset entries
1605            */
1606            public static void addAssetEntries(long pk,
1607                    List<com.liferay.portlet.asset.model.AssetEntry> assetEntries) {
1608                    getPersistence().addAssetEntries(pk, assetEntries);
1609            }
1610    
1611            /**
1612            * Clears all associations between the asset tag and its asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1613            *
1614            * @param pk the primary key of the asset tag to clear the associated asset entries from
1615            */
1616            public static void clearAssetEntries(long pk) {
1617                    getPersistence().clearAssetEntries(pk);
1618            }
1619    
1620            /**
1621            * Removes the association between the asset tag and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1622            *
1623            * @param pk the primary key of the asset tag
1624            * @param assetEntryPK the primary key of the asset entry
1625            */
1626            public static void removeAssetEntry(long pk, long assetEntryPK) {
1627                    getPersistence().removeAssetEntry(pk, assetEntryPK);
1628            }
1629    
1630            /**
1631            * Removes the association between the asset tag and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1632            *
1633            * @param pk the primary key of the asset tag
1634            * @param assetEntry the asset entry
1635            */
1636            public static void removeAssetEntry(long pk,
1637                    com.liferay.portlet.asset.model.AssetEntry assetEntry) {
1638                    getPersistence().removeAssetEntry(pk, assetEntry);
1639            }
1640    
1641            /**
1642            * Removes the association between the asset tag and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1643            *
1644            * @param pk the primary key of the asset tag
1645            * @param assetEntryPKs the primary keys of the asset entries
1646            */
1647            public static void removeAssetEntries(long pk, long[] assetEntryPKs) {
1648                    getPersistence().removeAssetEntries(pk, assetEntryPKs);
1649            }
1650    
1651            /**
1652            * Removes the association between the asset tag and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache.
1653            *
1654            * @param pk the primary key of the asset tag
1655            * @param assetEntries the asset entries
1656            */
1657            public static void removeAssetEntries(long pk,
1658                    List<com.liferay.portlet.asset.model.AssetEntry> assetEntries) {
1659                    getPersistence().removeAssetEntries(pk, assetEntries);
1660            }
1661    
1662            /**
1663            * 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.
1664            *
1665            * @param pk the primary key of the asset tag
1666            * @param assetEntryPKs the primary keys of the asset entries to be associated with the asset tag
1667            */
1668            public static void setAssetEntries(long pk, long[] assetEntryPKs) {
1669                    getPersistence().setAssetEntries(pk, assetEntryPKs);
1670            }
1671    
1672            /**
1673            * 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.
1674            *
1675            * @param pk the primary key of the asset tag
1676            * @param assetEntries the asset entries to be associated with the asset tag
1677            */
1678            public static void setAssetEntries(long pk,
1679                    List<com.liferay.portlet.asset.model.AssetEntry> assetEntries) {
1680                    getPersistence().setAssetEntries(pk, assetEntries);
1681            }
1682    
1683            public static java.util.Set<java.lang.String> getBadColumnNames() {
1684                    return getPersistence().getBadColumnNames();
1685            }
1686    
1687            public static AssetTagPersistence getPersistence() {
1688                    if (_persistence == null) {
1689                            _persistence = (AssetTagPersistence)PortalBeanLocatorUtil.locate(AssetTagPersistence.class.getName());
1690    
1691                            ReferenceRegistry.registerReference(AssetTagUtil.class,
1692                                    "_persistence");
1693                    }
1694    
1695                    return _persistence;
1696            }
1697    
1698            private static AssetTagPersistence _persistence;
1699    }