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.AssetLink;
026    
027    import java.util.List;
028    
029    /**
030     * The persistence utility for the asset link service. This utility wraps {@link com.liferay.portlet.asset.service.persistence.impl.AssetLinkPersistenceImpl} 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 AssetLinkPersistence
038     * @see com.liferay.portlet.asset.service.persistence.impl.AssetLinkPersistenceImpl
039     * @generated
040     */
041    @ProviderType
042    public class AssetLinkUtil {
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(AssetLink assetLink) {
060                    getPersistence().clearCache(assetLink);
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<AssetLink> findWithDynamicQuery(
074                    DynamicQuery dynamicQuery) {
075                    return getPersistence().findWithDynamicQuery(dynamicQuery);
076            }
077    
078            /**
079             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
080             */
081            public static List<AssetLink> findWithDynamicQuery(
082                    DynamicQuery dynamicQuery, int start, int end) {
083                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
084            }
085    
086            /**
087             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
088             */
089            public static List<AssetLink> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator<AssetLink> orderByComparator) {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
099             */
100            public static AssetLink update(AssetLink assetLink) {
101                    return getPersistence().update(assetLink);
102            }
103    
104            /**
105             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
106             */
107            public static AssetLink update(AssetLink assetLink,
108                    ServiceContext serviceContext) {
109                    return getPersistence().update(assetLink, serviceContext);
110            }
111    
112            /**
113            * Returns all the asset links where entryId1 = &#63;.
114            *
115            * @param entryId1 the entry id1
116            * @return the matching asset links
117            */
118            public static List<AssetLink> findByE1(long entryId1) {
119                    return getPersistence().findByE1(entryId1);
120            }
121    
122            /**
123            * Returns a range of all the asset links where entryId1 = &#63;.
124            *
125            * <p>
126            * 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 AssetLinkModelImpl}. 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.
127            * </p>
128            *
129            * @param entryId1 the entry id1
130            * @param start the lower bound of the range of asset links
131            * @param end the upper bound of the range of asset links (not inclusive)
132            * @return the range of matching asset links
133            */
134            public static List<AssetLink> findByE1(long entryId1, int start, int end) {
135                    return getPersistence().findByE1(entryId1, start, end);
136            }
137    
138            /**
139            * Returns an ordered range of all the asset links where entryId1 = &#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 AssetLinkModelImpl}. 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 entryId1 the entry id1
146            * @param start the lower bound of the range of asset links
147            * @param end the upper bound of the range of asset links (not inclusive)
148            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
149            * @return the ordered range of matching asset links
150            */
151            public static List<AssetLink> findByE1(long entryId1, int start, int end,
152                    OrderByComparator<AssetLink> orderByComparator) {
153                    return getPersistence().findByE1(entryId1, start, end, orderByComparator);
154            }
155    
156            /**
157            * Returns an ordered range of all the asset links where entryId1 = &#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 AssetLinkModelImpl}. 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 entryId1 the entry id1
164            * @param start the lower bound of the range of asset links
165            * @param end the upper bound of the range of asset links (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 links
169            */
170            public static List<AssetLink> findByE1(long entryId1, int start, int end,
171                    OrderByComparator<AssetLink> orderByComparator,
172                    boolean retrieveFromCache) {
173                    return getPersistence()
174                                       .findByE1(entryId1, start, end, orderByComparator,
175                            retrieveFromCache);
176            }
177    
178            /**
179            * Returns the first asset link in the ordered set where entryId1 = &#63;.
180            *
181            * @param entryId1 the entry id1
182            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
183            * @return the first matching asset link
184            * @throws NoSuchLinkException if a matching asset link could not be found
185            */
186            public static AssetLink findByE1_First(long entryId1,
187                    OrderByComparator<AssetLink> orderByComparator)
188                    throws com.liferay.portlet.asset.exception.NoSuchLinkException {
189                    return getPersistence().findByE1_First(entryId1, orderByComparator);
190            }
191    
192            /**
193            * Returns the first asset link in the ordered set where entryId1 = &#63;.
194            *
195            * @param entryId1 the entry id1
196            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
197            * @return the first matching asset link, or <code>null</code> if a matching asset link could not be found
198            */
199            public static AssetLink fetchByE1_First(long entryId1,
200                    OrderByComparator<AssetLink> orderByComparator) {
201                    return getPersistence().fetchByE1_First(entryId1, orderByComparator);
202            }
203    
204            /**
205            * Returns the last asset link in the ordered set where entryId1 = &#63;.
206            *
207            * @param entryId1 the entry id1
208            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
209            * @return the last matching asset link
210            * @throws NoSuchLinkException if a matching asset link could not be found
211            */
212            public static AssetLink findByE1_Last(long entryId1,
213                    OrderByComparator<AssetLink> orderByComparator)
214                    throws com.liferay.portlet.asset.exception.NoSuchLinkException {
215                    return getPersistence().findByE1_Last(entryId1, orderByComparator);
216            }
217    
218            /**
219            * Returns the last asset link in the ordered set where entryId1 = &#63;.
220            *
221            * @param entryId1 the entry id1
222            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
223            * @return the last matching asset link, or <code>null</code> if a matching asset link could not be found
224            */
225            public static AssetLink fetchByE1_Last(long entryId1,
226                    OrderByComparator<AssetLink> orderByComparator) {
227                    return getPersistence().fetchByE1_Last(entryId1, orderByComparator);
228            }
229    
230            /**
231            * Returns the asset links before and after the current asset link in the ordered set where entryId1 = &#63;.
232            *
233            * @param linkId the primary key of the current asset link
234            * @param entryId1 the entry id1
235            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
236            * @return the previous, current, and next asset link
237            * @throws NoSuchLinkException if a asset link with the primary key could not be found
238            */
239            public static AssetLink[] findByE1_PrevAndNext(long linkId, long entryId1,
240                    OrderByComparator<AssetLink> orderByComparator)
241                    throws com.liferay.portlet.asset.exception.NoSuchLinkException {
242                    return getPersistence()
243                                       .findByE1_PrevAndNext(linkId, entryId1, orderByComparator);
244            }
245    
246            /**
247            * Removes all the asset links where entryId1 = &#63; from the database.
248            *
249            * @param entryId1 the entry id1
250            */
251            public static void removeByE1(long entryId1) {
252                    getPersistence().removeByE1(entryId1);
253            }
254    
255            /**
256            * Returns the number of asset links where entryId1 = &#63;.
257            *
258            * @param entryId1 the entry id1
259            * @return the number of matching asset links
260            */
261            public static int countByE1(long entryId1) {
262                    return getPersistence().countByE1(entryId1);
263            }
264    
265            /**
266            * Returns all the asset links where entryId2 = &#63;.
267            *
268            * @param entryId2 the entry id2
269            * @return the matching asset links
270            */
271            public static List<AssetLink> findByE2(long entryId2) {
272                    return getPersistence().findByE2(entryId2);
273            }
274    
275            /**
276            * Returns a range of all the asset links where entryId2 = &#63;.
277            *
278            * <p>
279            * 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 AssetLinkModelImpl}. 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.
280            * </p>
281            *
282            * @param entryId2 the entry id2
283            * @param start the lower bound of the range of asset links
284            * @param end the upper bound of the range of asset links (not inclusive)
285            * @return the range of matching asset links
286            */
287            public static List<AssetLink> findByE2(long entryId2, int start, int end) {
288                    return getPersistence().findByE2(entryId2, start, end);
289            }
290    
291            /**
292            * Returns an ordered range of all the asset links where entryId2 = &#63;.
293            *
294            * <p>
295            * 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 AssetLinkModelImpl}. 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.
296            * </p>
297            *
298            * @param entryId2 the entry id2
299            * @param start the lower bound of the range of asset links
300            * @param end the upper bound of the range of asset links (not inclusive)
301            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
302            * @return the ordered range of matching asset links
303            */
304            public static List<AssetLink> findByE2(long entryId2, int start, int end,
305                    OrderByComparator<AssetLink> orderByComparator) {
306                    return getPersistence().findByE2(entryId2, start, end, orderByComparator);
307            }
308    
309            /**
310            * Returns an ordered range of all the asset links where entryId2 = &#63;.
311            *
312            * <p>
313            * 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 AssetLinkModelImpl}. 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.
314            * </p>
315            *
316            * @param entryId2 the entry id2
317            * @param start the lower bound of the range of asset links
318            * @param end the upper bound of the range of asset links (not inclusive)
319            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
320            * @param retrieveFromCache whether to retrieve from the finder cache
321            * @return the ordered range of matching asset links
322            */
323            public static List<AssetLink> findByE2(long entryId2, int start, int end,
324                    OrderByComparator<AssetLink> orderByComparator,
325                    boolean retrieveFromCache) {
326                    return getPersistence()
327                                       .findByE2(entryId2, start, end, orderByComparator,
328                            retrieveFromCache);
329            }
330    
331            /**
332            * Returns the first asset link in the ordered set where entryId2 = &#63;.
333            *
334            * @param entryId2 the entry id2
335            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
336            * @return the first matching asset link
337            * @throws NoSuchLinkException if a matching asset link could not be found
338            */
339            public static AssetLink findByE2_First(long entryId2,
340                    OrderByComparator<AssetLink> orderByComparator)
341                    throws com.liferay.portlet.asset.exception.NoSuchLinkException {
342                    return getPersistence().findByE2_First(entryId2, orderByComparator);
343            }
344    
345            /**
346            * Returns the first asset link in the ordered set where entryId2 = &#63;.
347            *
348            * @param entryId2 the entry id2
349            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
350            * @return the first matching asset link, or <code>null</code> if a matching asset link could not be found
351            */
352            public static AssetLink fetchByE2_First(long entryId2,
353                    OrderByComparator<AssetLink> orderByComparator) {
354                    return getPersistence().fetchByE2_First(entryId2, orderByComparator);
355            }
356    
357            /**
358            * Returns the last asset link in the ordered set where entryId2 = &#63;.
359            *
360            * @param entryId2 the entry id2
361            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
362            * @return the last matching asset link
363            * @throws NoSuchLinkException if a matching asset link could not be found
364            */
365            public static AssetLink findByE2_Last(long entryId2,
366                    OrderByComparator<AssetLink> orderByComparator)
367                    throws com.liferay.portlet.asset.exception.NoSuchLinkException {
368                    return getPersistence().findByE2_Last(entryId2, orderByComparator);
369            }
370    
371            /**
372            * Returns the last asset link in the ordered set where entryId2 = &#63;.
373            *
374            * @param entryId2 the entry id2
375            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
376            * @return the last matching asset link, or <code>null</code> if a matching asset link could not be found
377            */
378            public static AssetLink fetchByE2_Last(long entryId2,
379                    OrderByComparator<AssetLink> orderByComparator) {
380                    return getPersistence().fetchByE2_Last(entryId2, orderByComparator);
381            }
382    
383            /**
384            * Returns the asset links before and after the current asset link in the ordered set where entryId2 = &#63;.
385            *
386            * @param linkId the primary key of the current asset link
387            * @param entryId2 the entry id2
388            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
389            * @return the previous, current, and next asset link
390            * @throws NoSuchLinkException if a asset link with the primary key could not be found
391            */
392            public static AssetLink[] findByE2_PrevAndNext(long linkId, long entryId2,
393                    OrderByComparator<AssetLink> orderByComparator)
394                    throws com.liferay.portlet.asset.exception.NoSuchLinkException {
395                    return getPersistence()
396                                       .findByE2_PrevAndNext(linkId, entryId2, orderByComparator);
397            }
398    
399            /**
400            * Removes all the asset links where entryId2 = &#63; from the database.
401            *
402            * @param entryId2 the entry id2
403            */
404            public static void removeByE2(long entryId2) {
405                    getPersistence().removeByE2(entryId2);
406            }
407    
408            /**
409            * Returns the number of asset links where entryId2 = &#63;.
410            *
411            * @param entryId2 the entry id2
412            * @return the number of matching asset links
413            */
414            public static int countByE2(long entryId2) {
415                    return getPersistence().countByE2(entryId2);
416            }
417    
418            /**
419            * Returns all the asset links where entryId1 = &#63; and entryId2 = &#63;.
420            *
421            * @param entryId1 the entry id1
422            * @param entryId2 the entry id2
423            * @return the matching asset links
424            */
425            public static List<AssetLink> findByE_E(long entryId1, long entryId2) {
426                    return getPersistence().findByE_E(entryId1, entryId2);
427            }
428    
429            /**
430            * Returns a range of all the asset links where entryId1 = &#63; and entryId2 = &#63;.
431            *
432            * <p>
433            * 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 AssetLinkModelImpl}. 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.
434            * </p>
435            *
436            * @param entryId1 the entry id1
437            * @param entryId2 the entry id2
438            * @param start the lower bound of the range of asset links
439            * @param end the upper bound of the range of asset links (not inclusive)
440            * @return the range of matching asset links
441            */
442            public static List<AssetLink> findByE_E(long entryId1, long entryId2,
443                    int start, int end) {
444                    return getPersistence().findByE_E(entryId1, entryId2, start, end);
445            }
446    
447            /**
448            * Returns an ordered range of all the asset links where entryId1 = &#63; and entryId2 = &#63;.
449            *
450            * <p>
451            * 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 AssetLinkModelImpl}. 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.
452            * </p>
453            *
454            * @param entryId1 the entry id1
455            * @param entryId2 the entry id2
456            * @param start the lower bound of the range of asset links
457            * @param end the upper bound of the range of asset links (not inclusive)
458            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
459            * @return the ordered range of matching asset links
460            */
461            public static List<AssetLink> findByE_E(long entryId1, long entryId2,
462                    int start, int end, OrderByComparator<AssetLink> orderByComparator) {
463                    return getPersistence()
464                                       .findByE_E(entryId1, entryId2, start, end, orderByComparator);
465            }
466    
467            /**
468            * Returns an ordered range of all the asset links where entryId1 = &#63; and entryId2 = &#63;.
469            *
470            * <p>
471            * 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 AssetLinkModelImpl}. 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.
472            * </p>
473            *
474            * @param entryId1 the entry id1
475            * @param entryId2 the entry id2
476            * @param start the lower bound of the range of asset links
477            * @param end the upper bound of the range of asset links (not inclusive)
478            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
479            * @param retrieveFromCache whether to retrieve from the finder cache
480            * @return the ordered range of matching asset links
481            */
482            public static List<AssetLink> findByE_E(long entryId1, long entryId2,
483                    int start, int end, OrderByComparator<AssetLink> orderByComparator,
484                    boolean retrieveFromCache) {
485                    return getPersistence()
486                                       .findByE_E(entryId1, entryId2, start, end,
487                            orderByComparator, retrieveFromCache);
488            }
489    
490            /**
491            * Returns the first asset link in the ordered set where entryId1 = &#63; and entryId2 = &#63;.
492            *
493            * @param entryId1 the entry id1
494            * @param entryId2 the entry id2
495            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
496            * @return the first matching asset link
497            * @throws NoSuchLinkException if a matching asset link could not be found
498            */
499            public static AssetLink findByE_E_First(long entryId1, long entryId2,
500                    OrderByComparator<AssetLink> orderByComparator)
501                    throws com.liferay.portlet.asset.exception.NoSuchLinkException {
502                    return getPersistence()
503                                       .findByE_E_First(entryId1, entryId2, orderByComparator);
504            }
505    
506            /**
507            * Returns the first asset link in the ordered set where entryId1 = &#63; and entryId2 = &#63;.
508            *
509            * @param entryId1 the entry id1
510            * @param entryId2 the entry id2
511            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
512            * @return the first matching asset link, or <code>null</code> if a matching asset link could not be found
513            */
514            public static AssetLink fetchByE_E_First(long entryId1, long entryId2,
515                    OrderByComparator<AssetLink> orderByComparator) {
516                    return getPersistence()
517                                       .fetchByE_E_First(entryId1, entryId2, orderByComparator);
518            }
519    
520            /**
521            * Returns the last asset link in the ordered set where entryId1 = &#63; and entryId2 = &#63;.
522            *
523            * @param entryId1 the entry id1
524            * @param entryId2 the entry id2
525            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
526            * @return the last matching asset link
527            * @throws NoSuchLinkException if a matching asset link could not be found
528            */
529            public static AssetLink findByE_E_Last(long entryId1, long entryId2,
530                    OrderByComparator<AssetLink> orderByComparator)
531                    throws com.liferay.portlet.asset.exception.NoSuchLinkException {
532                    return getPersistence()
533                                       .findByE_E_Last(entryId1, entryId2, orderByComparator);
534            }
535    
536            /**
537            * Returns the last asset link in the ordered set where entryId1 = &#63; and entryId2 = &#63;.
538            *
539            * @param entryId1 the entry id1
540            * @param entryId2 the entry id2
541            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
542            * @return the last matching asset link, or <code>null</code> if a matching asset link could not be found
543            */
544            public static AssetLink fetchByE_E_Last(long entryId1, long entryId2,
545                    OrderByComparator<AssetLink> orderByComparator) {
546                    return getPersistence()
547                                       .fetchByE_E_Last(entryId1, entryId2, orderByComparator);
548            }
549    
550            /**
551            * Returns the asset links before and after the current asset link in the ordered set where entryId1 = &#63; and entryId2 = &#63;.
552            *
553            * @param linkId the primary key of the current asset link
554            * @param entryId1 the entry id1
555            * @param entryId2 the entry id2
556            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
557            * @return the previous, current, and next asset link
558            * @throws NoSuchLinkException if a asset link with the primary key could not be found
559            */
560            public static AssetLink[] findByE_E_PrevAndNext(long linkId, long entryId1,
561                    long entryId2, OrderByComparator<AssetLink> orderByComparator)
562                    throws com.liferay.portlet.asset.exception.NoSuchLinkException {
563                    return getPersistence()
564                                       .findByE_E_PrevAndNext(linkId, entryId1, entryId2,
565                            orderByComparator);
566            }
567    
568            /**
569            * Removes all the asset links where entryId1 = &#63; and entryId2 = &#63; from the database.
570            *
571            * @param entryId1 the entry id1
572            * @param entryId2 the entry id2
573            */
574            public static void removeByE_E(long entryId1, long entryId2) {
575                    getPersistence().removeByE_E(entryId1, entryId2);
576            }
577    
578            /**
579            * Returns the number of asset links where entryId1 = &#63; and entryId2 = &#63;.
580            *
581            * @param entryId1 the entry id1
582            * @param entryId2 the entry id2
583            * @return the number of matching asset links
584            */
585            public static int countByE_E(long entryId1, long entryId2) {
586                    return getPersistence().countByE_E(entryId1, entryId2);
587            }
588    
589            /**
590            * Returns all the asset links where entryId1 = &#63; and type = &#63;.
591            *
592            * @param entryId1 the entry id1
593            * @param type the type
594            * @return the matching asset links
595            */
596            public static List<AssetLink> findByE1_T(long entryId1, int type) {
597                    return getPersistence().findByE1_T(entryId1, type);
598            }
599    
600            /**
601            * Returns a range of all the asset links where entryId1 = &#63; and type = &#63;.
602            *
603            * <p>
604            * 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 AssetLinkModelImpl}. 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.
605            * </p>
606            *
607            * @param entryId1 the entry id1
608            * @param type the type
609            * @param start the lower bound of the range of asset links
610            * @param end the upper bound of the range of asset links (not inclusive)
611            * @return the range of matching asset links
612            */
613            public static List<AssetLink> findByE1_T(long entryId1, int type,
614                    int start, int end) {
615                    return getPersistence().findByE1_T(entryId1, type, start, end);
616            }
617    
618            /**
619            * Returns an ordered range of all the asset links where entryId1 = &#63; and type = &#63;.
620            *
621            * <p>
622            * 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 AssetLinkModelImpl}. 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.
623            * </p>
624            *
625            * @param entryId1 the entry id1
626            * @param type the type
627            * @param start the lower bound of the range of asset links
628            * @param end the upper bound of the range of asset links (not inclusive)
629            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
630            * @return the ordered range of matching asset links
631            */
632            public static List<AssetLink> findByE1_T(long entryId1, int type,
633                    int start, int end, OrderByComparator<AssetLink> orderByComparator) {
634                    return getPersistence()
635                                       .findByE1_T(entryId1, type, start, end, orderByComparator);
636            }
637    
638            /**
639            * Returns an ordered range of all the asset links where entryId1 = &#63; and type = &#63;.
640            *
641            * <p>
642            * 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 AssetLinkModelImpl}. 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.
643            * </p>
644            *
645            * @param entryId1 the entry id1
646            * @param type the type
647            * @param start the lower bound of the range of asset links
648            * @param end the upper bound of the range of asset links (not inclusive)
649            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
650            * @param retrieveFromCache whether to retrieve from the finder cache
651            * @return the ordered range of matching asset links
652            */
653            public static List<AssetLink> findByE1_T(long entryId1, int type,
654                    int start, int end, OrderByComparator<AssetLink> orderByComparator,
655                    boolean retrieveFromCache) {
656                    return getPersistence()
657                                       .findByE1_T(entryId1, type, start, end, orderByComparator,
658                            retrieveFromCache);
659            }
660    
661            /**
662            * Returns the first asset link in the ordered set where entryId1 = &#63; and type = &#63;.
663            *
664            * @param entryId1 the entry id1
665            * @param type the type
666            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
667            * @return the first matching asset link
668            * @throws NoSuchLinkException if a matching asset link could not be found
669            */
670            public static AssetLink findByE1_T_First(long entryId1, int type,
671                    OrderByComparator<AssetLink> orderByComparator)
672                    throws com.liferay.portlet.asset.exception.NoSuchLinkException {
673                    return getPersistence()
674                                       .findByE1_T_First(entryId1, type, orderByComparator);
675            }
676    
677            /**
678            * Returns the first asset link in the ordered set where entryId1 = &#63; and type = &#63;.
679            *
680            * @param entryId1 the entry id1
681            * @param type the type
682            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
683            * @return the first matching asset link, or <code>null</code> if a matching asset link could not be found
684            */
685            public static AssetLink fetchByE1_T_First(long entryId1, int type,
686                    OrderByComparator<AssetLink> orderByComparator) {
687                    return getPersistence()
688                                       .fetchByE1_T_First(entryId1, type, orderByComparator);
689            }
690    
691            /**
692            * Returns the last asset link in the ordered set where entryId1 = &#63; and type = &#63;.
693            *
694            * @param entryId1 the entry id1
695            * @param type the type
696            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
697            * @return the last matching asset link
698            * @throws NoSuchLinkException if a matching asset link could not be found
699            */
700            public static AssetLink findByE1_T_Last(long entryId1, int type,
701                    OrderByComparator<AssetLink> orderByComparator)
702                    throws com.liferay.portlet.asset.exception.NoSuchLinkException {
703                    return getPersistence()
704                                       .findByE1_T_Last(entryId1, type, orderByComparator);
705            }
706    
707            /**
708            * Returns the last asset link in the ordered set where entryId1 = &#63; and type = &#63;.
709            *
710            * @param entryId1 the entry id1
711            * @param type the type
712            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
713            * @return the last matching asset link, or <code>null</code> if a matching asset link could not be found
714            */
715            public static AssetLink fetchByE1_T_Last(long entryId1, int type,
716                    OrderByComparator<AssetLink> orderByComparator) {
717                    return getPersistence()
718                                       .fetchByE1_T_Last(entryId1, type, orderByComparator);
719            }
720    
721            /**
722            * Returns the asset links before and after the current asset link in the ordered set where entryId1 = &#63; and type = &#63;.
723            *
724            * @param linkId the primary key of the current asset link
725            * @param entryId1 the entry id1
726            * @param type the type
727            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
728            * @return the previous, current, and next asset link
729            * @throws NoSuchLinkException if a asset link with the primary key could not be found
730            */
731            public static AssetLink[] findByE1_T_PrevAndNext(long linkId,
732                    long entryId1, int type, OrderByComparator<AssetLink> orderByComparator)
733                    throws com.liferay.portlet.asset.exception.NoSuchLinkException {
734                    return getPersistence()
735                                       .findByE1_T_PrevAndNext(linkId, entryId1, type,
736                            orderByComparator);
737            }
738    
739            /**
740            * Removes all the asset links where entryId1 = &#63; and type = &#63; from the database.
741            *
742            * @param entryId1 the entry id1
743            * @param type the type
744            */
745            public static void removeByE1_T(long entryId1, int type) {
746                    getPersistence().removeByE1_T(entryId1, type);
747            }
748    
749            /**
750            * Returns the number of asset links where entryId1 = &#63; and type = &#63;.
751            *
752            * @param entryId1 the entry id1
753            * @param type the type
754            * @return the number of matching asset links
755            */
756            public static int countByE1_T(long entryId1, int type) {
757                    return getPersistence().countByE1_T(entryId1, type);
758            }
759    
760            /**
761            * Returns all the asset links where entryId2 = &#63; and type = &#63;.
762            *
763            * @param entryId2 the entry id2
764            * @param type the type
765            * @return the matching asset links
766            */
767            public static List<AssetLink> findByE2_T(long entryId2, int type) {
768                    return getPersistence().findByE2_T(entryId2, type);
769            }
770    
771            /**
772            * Returns a range of all the asset links where entryId2 = &#63; and type = &#63;.
773            *
774            * <p>
775            * 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 AssetLinkModelImpl}. 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.
776            * </p>
777            *
778            * @param entryId2 the entry id2
779            * @param type the type
780            * @param start the lower bound of the range of asset links
781            * @param end the upper bound of the range of asset links (not inclusive)
782            * @return the range of matching asset links
783            */
784            public static List<AssetLink> findByE2_T(long entryId2, int type,
785                    int start, int end) {
786                    return getPersistence().findByE2_T(entryId2, type, start, end);
787            }
788    
789            /**
790            * Returns an ordered range of all the asset links where entryId2 = &#63; and type = &#63;.
791            *
792            * <p>
793            * 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 AssetLinkModelImpl}. 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.
794            * </p>
795            *
796            * @param entryId2 the entry id2
797            * @param type the type
798            * @param start the lower bound of the range of asset links
799            * @param end the upper bound of the range of asset links (not inclusive)
800            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
801            * @return the ordered range of matching asset links
802            */
803            public static List<AssetLink> findByE2_T(long entryId2, int type,
804                    int start, int end, OrderByComparator<AssetLink> orderByComparator) {
805                    return getPersistence()
806                                       .findByE2_T(entryId2, type, start, end, orderByComparator);
807            }
808    
809            /**
810            * Returns an ordered range of all the asset links where entryId2 = &#63; and type = &#63;.
811            *
812            * <p>
813            * 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 AssetLinkModelImpl}. 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.
814            * </p>
815            *
816            * @param entryId2 the entry id2
817            * @param type the type
818            * @param start the lower bound of the range of asset links
819            * @param end the upper bound of the range of asset links (not inclusive)
820            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
821            * @param retrieveFromCache whether to retrieve from the finder cache
822            * @return the ordered range of matching asset links
823            */
824            public static List<AssetLink> findByE2_T(long entryId2, int type,
825                    int start, int end, OrderByComparator<AssetLink> orderByComparator,
826                    boolean retrieveFromCache) {
827                    return getPersistence()
828                                       .findByE2_T(entryId2, type, start, end, orderByComparator,
829                            retrieveFromCache);
830            }
831    
832            /**
833            * Returns the first asset link in the ordered set where entryId2 = &#63; and type = &#63;.
834            *
835            * @param entryId2 the entry id2
836            * @param type the type
837            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
838            * @return the first matching asset link
839            * @throws NoSuchLinkException if a matching asset link could not be found
840            */
841            public static AssetLink findByE2_T_First(long entryId2, int type,
842                    OrderByComparator<AssetLink> orderByComparator)
843                    throws com.liferay.portlet.asset.exception.NoSuchLinkException {
844                    return getPersistence()
845                                       .findByE2_T_First(entryId2, type, orderByComparator);
846            }
847    
848            /**
849            * Returns the first asset link in the ordered set where entryId2 = &#63; and type = &#63;.
850            *
851            * @param entryId2 the entry id2
852            * @param type the type
853            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
854            * @return the first matching asset link, or <code>null</code> if a matching asset link could not be found
855            */
856            public static AssetLink fetchByE2_T_First(long entryId2, int type,
857                    OrderByComparator<AssetLink> orderByComparator) {
858                    return getPersistence()
859                                       .fetchByE2_T_First(entryId2, type, orderByComparator);
860            }
861    
862            /**
863            * Returns the last asset link in the ordered set where entryId2 = &#63; and type = &#63;.
864            *
865            * @param entryId2 the entry id2
866            * @param type the type
867            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
868            * @return the last matching asset link
869            * @throws NoSuchLinkException if a matching asset link could not be found
870            */
871            public static AssetLink findByE2_T_Last(long entryId2, int type,
872                    OrderByComparator<AssetLink> orderByComparator)
873                    throws com.liferay.portlet.asset.exception.NoSuchLinkException {
874                    return getPersistence()
875                                       .findByE2_T_Last(entryId2, type, orderByComparator);
876            }
877    
878            /**
879            * Returns the last asset link in the ordered set where entryId2 = &#63; and type = &#63;.
880            *
881            * @param entryId2 the entry id2
882            * @param type the type
883            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
884            * @return the last matching asset link, or <code>null</code> if a matching asset link could not be found
885            */
886            public static AssetLink fetchByE2_T_Last(long entryId2, int type,
887                    OrderByComparator<AssetLink> orderByComparator) {
888                    return getPersistence()
889                                       .fetchByE2_T_Last(entryId2, type, orderByComparator);
890            }
891    
892            /**
893            * Returns the asset links before and after the current asset link in the ordered set where entryId2 = &#63; and type = &#63;.
894            *
895            * @param linkId the primary key of the current asset link
896            * @param entryId2 the entry id2
897            * @param type the type
898            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
899            * @return the previous, current, and next asset link
900            * @throws NoSuchLinkException if a asset link with the primary key could not be found
901            */
902            public static AssetLink[] findByE2_T_PrevAndNext(long linkId,
903                    long entryId2, int type, OrderByComparator<AssetLink> orderByComparator)
904                    throws com.liferay.portlet.asset.exception.NoSuchLinkException {
905                    return getPersistence()
906                                       .findByE2_T_PrevAndNext(linkId, entryId2, type,
907                            orderByComparator);
908            }
909    
910            /**
911            * Removes all the asset links where entryId2 = &#63; and type = &#63; from the database.
912            *
913            * @param entryId2 the entry id2
914            * @param type the type
915            */
916            public static void removeByE2_T(long entryId2, int type) {
917                    getPersistence().removeByE2_T(entryId2, type);
918            }
919    
920            /**
921            * Returns the number of asset links where entryId2 = &#63; and type = &#63;.
922            *
923            * @param entryId2 the entry id2
924            * @param type the type
925            * @return the number of matching asset links
926            */
927            public static int countByE2_T(long entryId2, int type) {
928                    return getPersistence().countByE2_T(entryId2, type);
929            }
930    
931            /**
932            * Returns the asset link where entryId1 = &#63; and entryId2 = &#63; and type = &#63; or throws a {@link NoSuchLinkException} if it could not be found.
933            *
934            * @param entryId1 the entry id1
935            * @param entryId2 the entry id2
936            * @param type the type
937            * @return the matching asset link
938            * @throws NoSuchLinkException if a matching asset link could not be found
939            */
940            public static AssetLink findByE_E_T(long entryId1, long entryId2, int type)
941                    throws com.liferay.portlet.asset.exception.NoSuchLinkException {
942                    return getPersistence().findByE_E_T(entryId1, entryId2, type);
943            }
944    
945            /**
946            * Returns the asset link where entryId1 = &#63; and entryId2 = &#63; and type = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
947            *
948            * @param entryId1 the entry id1
949            * @param entryId2 the entry id2
950            * @param type the type
951            * @return the matching asset link, or <code>null</code> if a matching asset link could not be found
952            */
953            public static AssetLink fetchByE_E_T(long entryId1, long entryId2, int type) {
954                    return getPersistence().fetchByE_E_T(entryId1, entryId2, type);
955            }
956    
957            /**
958            * Returns the asset link where entryId1 = &#63; and entryId2 = &#63; and type = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
959            *
960            * @param entryId1 the entry id1
961            * @param entryId2 the entry id2
962            * @param type the type
963            * @param retrieveFromCache whether to retrieve from the finder cache
964            * @return the matching asset link, or <code>null</code> if a matching asset link could not be found
965            */
966            public static AssetLink fetchByE_E_T(long entryId1, long entryId2,
967                    int type, boolean retrieveFromCache) {
968                    return getPersistence()
969                                       .fetchByE_E_T(entryId1, entryId2, type, retrieveFromCache);
970            }
971    
972            /**
973            * Removes the asset link where entryId1 = &#63; and entryId2 = &#63; and type = &#63; from the database.
974            *
975            * @param entryId1 the entry id1
976            * @param entryId2 the entry id2
977            * @param type the type
978            * @return the asset link that was removed
979            */
980            public static AssetLink removeByE_E_T(long entryId1, long entryId2, int type)
981                    throws com.liferay.portlet.asset.exception.NoSuchLinkException {
982                    return getPersistence().removeByE_E_T(entryId1, entryId2, type);
983            }
984    
985            /**
986            * Returns the number of asset links where entryId1 = &#63; and entryId2 = &#63; and type = &#63;.
987            *
988            * @param entryId1 the entry id1
989            * @param entryId2 the entry id2
990            * @param type the type
991            * @return the number of matching asset links
992            */
993            public static int countByE_E_T(long entryId1, long entryId2, int type) {
994                    return getPersistence().countByE_E_T(entryId1, entryId2, type);
995            }
996    
997            /**
998            * Caches the asset link in the entity cache if it is enabled.
999            *
1000            * @param assetLink the asset link
1001            */
1002            public static void cacheResult(AssetLink assetLink) {
1003                    getPersistence().cacheResult(assetLink);
1004            }
1005    
1006            /**
1007            * Caches the asset links in the entity cache if it is enabled.
1008            *
1009            * @param assetLinks the asset links
1010            */
1011            public static void cacheResult(List<AssetLink> assetLinks) {
1012                    getPersistence().cacheResult(assetLinks);
1013            }
1014    
1015            /**
1016            * Creates a new asset link with the primary key. Does not add the asset link to the database.
1017            *
1018            * @param linkId the primary key for the new asset link
1019            * @return the new asset link
1020            */
1021            public static AssetLink create(long linkId) {
1022                    return getPersistence().create(linkId);
1023            }
1024    
1025            /**
1026            * Removes the asset link with the primary key from the database. Also notifies the appropriate model listeners.
1027            *
1028            * @param linkId the primary key of the asset link
1029            * @return the asset link that was removed
1030            * @throws NoSuchLinkException if a asset link with the primary key could not be found
1031            */
1032            public static AssetLink remove(long linkId)
1033                    throws com.liferay.portlet.asset.exception.NoSuchLinkException {
1034                    return getPersistence().remove(linkId);
1035            }
1036    
1037            public static AssetLink updateImpl(AssetLink assetLink) {
1038                    return getPersistence().updateImpl(assetLink);
1039            }
1040    
1041            /**
1042            * Returns the asset link with the primary key or throws a {@link NoSuchLinkException} if it could not be found.
1043            *
1044            * @param linkId the primary key of the asset link
1045            * @return the asset link
1046            * @throws NoSuchLinkException if a asset link with the primary key could not be found
1047            */
1048            public static AssetLink findByPrimaryKey(long linkId)
1049                    throws com.liferay.portlet.asset.exception.NoSuchLinkException {
1050                    return getPersistence().findByPrimaryKey(linkId);
1051            }
1052    
1053            /**
1054            * Returns the asset link with the primary key or returns <code>null</code> if it could not be found.
1055            *
1056            * @param linkId the primary key of the asset link
1057            * @return the asset link, or <code>null</code> if a asset link with the primary key could not be found
1058            */
1059            public static AssetLink fetchByPrimaryKey(long linkId) {
1060                    return getPersistence().fetchByPrimaryKey(linkId);
1061            }
1062    
1063            public static java.util.Map<java.io.Serializable, AssetLink> fetchByPrimaryKeys(
1064                    java.util.Set<java.io.Serializable> primaryKeys) {
1065                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
1066            }
1067    
1068            /**
1069            * Returns all the asset links.
1070            *
1071            * @return the asset links
1072            */
1073            public static List<AssetLink> findAll() {
1074                    return getPersistence().findAll();
1075            }
1076    
1077            /**
1078            * Returns a range of all the asset links.
1079            *
1080            * <p>
1081            * 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 AssetLinkModelImpl}. 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.
1082            * </p>
1083            *
1084            * @param start the lower bound of the range of asset links
1085            * @param end the upper bound of the range of asset links (not inclusive)
1086            * @return the range of asset links
1087            */
1088            public static List<AssetLink> findAll(int start, int end) {
1089                    return getPersistence().findAll(start, end);
1090            }
1091    
1092            /**
1093            * Returns an ordered range of all the asset links.
1094            *
1095            * <p>
1096            * 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 AssetLinkModelImpl}. 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.
1097            * </p>
1098            *
1099            * @param start the lower bound of the range of asset links
1100            * @param end the upper bound of the range of asset links (not inclusive)
1101            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1102            * @return the ordered range of asset links
1103            */
1104            public static List<AssetLink> findAll(int start, int end,
1105                    OrderByComparator<AssetLink> orderByComparator) {
1106                    return getPersistence().findAll(start, end, orderByComparator);
1107            }
1108    
1109            /**
1110            * Returns an ordered range of all the asset links.
1111            *
1112            * <p>
1113            * 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 AssetLinkModelImpl}. 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.
1114            * </p>
1115            *
1116            * @param start the lower bound of the range of asset links
1117            * @param end the upper bound of the range of asset links (not inclusive)
1118            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1119            * @param retrieveFromCache whether to retrieve from the finder cache
1120            * @return the ordered range of asset links
1121            */
1122            public static List<AssetLink> findAll(int start, int end,
1123                    OrderByComparator<AssetLink> orderByComparator,
1124                    boolean retrieveFromCache) {
1125                    return getPersistence()
1126                                       .findAll(start, end, orderByComparator, retrieveFromCache);
1127            }
1128    
1129            /**
1130            * Removes all the asset links from the database.
1131            */
1132            public static void removeAll() {
1133                    getPersistence().removeAll();
1134            }
1135    
1136            /**
1137            * Returns the number of asset links.
1138            *
1139            * @return the number of asset links
1140            */
1141            public static int countAll() {
1142                    return getPersistence().countAll();
1143            }
1144    
1145            public static java.util.Set<java.lang.String> getBadColumnNames() {
1146                    return getPersistence().getBadColumnNames();
1147            }
1148    
1149            public static AssetLinkPersistence getPersistence() {
1150                    if (_persistence == null) {
1151                            _persistence = (AssetLinkPersistence)PortalBeanLocatorUtil.locate(AssetLinkPersistence.class.getName());
1152    
1153                            ReferenceRegistry.registerReference(AssetLinkUtil.class,
1154                                    "_persistence");
1155                    }
1156    
1157                    return _persistence;
1158            }
1159    
1160            private static AssetLinkPersistence _persistence;
1161    }