1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * This library is free software; you can redistribute it and/or modify it under
5    * the terms of the GNU Lesser General Public License as published by the Free
6    * Software Foundation; either version 2.1 of the License, or (at your option)
7    * any later version.
8    *
9    * This library is distributed in the hope that it will be useful, but WITHOUT
10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11   * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
12   * details.
13   */
14  
15  package com.liferay.portlet.asset.service.persistence;
16  
17  import com.liferay.portal.NoSuchModelException;
18  import com.liferay.portal.kernel.annotation.BeanReference;
19  import com.liferay.portal.kernel.cache.CacheRegistry;
20  import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
21  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
22  import com.liferay.portal.kernel.dao.orm.FinderPath;
23  import com.liferay.portal.kernel.dao.orm.Query;
24  import com.liferay.portal.kernel.dao.orm.QueryPos;
25  import com.liferay.portal.kernel.dao.orm.QueryUtil;
26  import com.liferay.portal.kernel.dao.orm.Session;
27  import com.liferay.portal.kernel.exception.SystemException;
28  import com.liferay.portal.kernel.log.Log;
29  import com.liferay.portal.kernel.log.LogFactoryUtil;
30  import com.liferay.portal.kernel.util.GetterUtil;
31  import com.liferay.portal.kernel.util.InstanceFactory;
32  import com.liferay.portal.kernel.util.OrderByComparator;
33  import com.liferay.portal.kernel.util.StringBundler;
34  import com.liferay.portal.kernel.util.StringPool;
35  import com.liferay.portal.kernel.util.StringUtil;
36  import com.liferay.portal.model.ModelListener;
37  import com.liferay.portal.service.persistence.BatchSessionUtil;
38  import com.liferay.portal.service.persistence.ResourcePersistence;
39  import com.liferay.portal.service.persistence.UserPersistence;
40  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
41  
42  import com.liferay.portlet.asset.NoSuchLinkException;
43  import com.liferay.portlet.asset.model.AssetLink;
44  import com.liferay.portlet.asset.model.impl.AssetLinkImpl;
45  import com.liferay.portlet.asset.model.impl.AssetLinkModelImpl;
46  
47  import java.io.Serializable;
48  
49  import java.util.ArrayList;
50  import java.util.Collections;
51  import java.util.List;
52  
53  /**
54   * <a href="AssetLinkPersistenceImpl.java.html"><b><i>View Source</i></b></a>
55   *
56   * <p>
57   * ServiceBuilder generated this class. Modifications in this class will be
58   * overwritten the next time is generated.
59   * </p>
60   *
61   * @author    Brian Wing Shun Chan
62   * @see       AssetLinkPersistence
63   * @see       AssetLinkUtil
64   * @generated
65   */
66  public class AssetLinkPersistenceImpl extends BasePersistenceImpl<AssetLink>
67      implements AssetLinkPersistence {
68      public static final String FINDER_CLASS_NAME_ENTITY = AssetLinkImpl.class.getName();
69      public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
70          ".List";
71      public static final FinderPath FINDER_PATH_FIND_BY_E1 = new FinderPath(AssetLinkModelImpl.ENTITY_CACHE_ENABLED,
72              AssetLinkModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
73              "findByE1",
74              new String[] {
75                  Long.class.getName(),
76                  
77              "java.lang.Integer", "java.lang.Integer",
78                  "com.liferay.portal.kernel.util.OrderByComparator"
79              });
80      public static final FinderPath FINDER_PATH_COUNT_BY_E1 = new FinderPath(AssetLinkModelImpl.ENTITY_CACHE_ENABLED,
81              AssetLinkModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
82              "countByE1", new String[] { Long.class.getName() });
83      public static final FinderPath FINDER_PATH_FIND_BY_E2 = new FinderPath(AssetLinkModelImpl.ENTITY_CACHE_ENABLED,
84              AssetLinkModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
85              "findByE2",
86              new String[] {
87                  Long.class.getName(),
88                  
89              "java.lang.Integer", "java.lang.Integer",
90                  "com.liferay.portal.kernel.util.OrderByComparator"
91              });
92      public static final FinderPath FINDER_PATH_COUNT_BY_E2 = new FinderPath(AssetLinkModelImpl.ENTITY_CACHE_ENABLED,
93              AssetLinkModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
94              "countByE2", new String[] { Long.class.getName() });
95      public static final FinderPath FINDER_PATH_FIND_BY_E_E = new FinderPath(AssetLinkModelImpl.ENTITY_CACHE_ENABLED,
96              AssetLinkModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
97              "findByE_E",
98              new String[] {
99                  Long.class.getName(), Long.class.getName(),
100                 
101             "java.lang.Integer", "java.lang.Integer",
102                 "com.liferay.portal.kernel.util.OrderByComparator"
103             });
104     public static final FinderPath FINDER_PATH_COUNT_BY_E_E = new FinderPath(AssetLinkModelImpl.ENTITY_CACHE_ENABLED,
105             AssetLinkModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
106             "countByE_E",
107             new String[] { Long.class.getName(), Long.class.getName() });
108     public static final FinderPath FINDER_PATH_FIND_BY_E1_T = new FinderPath(AssetLinkModelImpl.ENTITY_CACHE_ENABLED,
109             AssetLinkModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
110             "findByE1_T",
111             new String[] {
112                 Long.class.getName(), Integer.class.getName(),
113                 
114             "java.lang.Integer", "java.lang.Integer",
115                 "com.liferay.portal.kernel.util.OrderByComparator"
116             });
117     public static final FinderPath FINDER_PATH_COUNT_BY_E1_T = new FinderPath(AssetLinkModelImpl.ENTITY_CACHE_ENABLED,
118             AssetLinkModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
119             "countByE1_T",
120             new String[] { Long.class.getName(), Integer.class.getName() });
121     public static final FinderPath FINDER_PATH_FIND_BY_E2_T = new FinderPath(AssetLinkModelImpl.ENTITY_CACHE_ENABLED,
122             AssetLinkModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
123             "findByE2_T",
124             new String[] {
125                 Long.class.getName(), Integer.class.getName(),
126                 
127             "java.lang.Integer", "java.lang.Integer",
128                 "com.liferay.portal.kernel.util.OrderByComparator"
129             });
130     public static final FinderPath FINDER_PATH_COUNT_BY_E2_T = new FinderPath(AssetLinkModelImpl.ENTITY_CACHE_ENABLED,
131             AssetLinkModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
132             "countByE2_T",
133             new String[] { Long.class.getName(), Integer.class.getName() });
134     public static final FinderPath FINDER_PATH_FIND_BY_E_E_T = new FinderPath(AssetLinkModelImpl.ENTITY_CACHE_ENABLED,
135             AssetLinkModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
136             "findByE_E_T",
137             new String[] {
138                 Long.class.getName(), Long.class.getName(),
139                 Integer.class.getName(),
140                 
141             "java.lang.Integer", "java.lang.Integer",
142                 "com.liferay.portal.kernel.util.OrderByComparator"
143             });
144     public static final FinderPath FINDER_PATH_COUNT_BY_E_E_T = new FinderPath(AssetLinkModelImpl.ENTITY_CACHE_ENABLED,
145             AssetLinkModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
146             "countByE_E_T",
147             new String[] {
148                 Long.class.getName(), Long.class.getName(),
149                 Integer.class.getName()
150             });
151     public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(AssetLinkModelImpl.ENTITY_CACHE_ENABLED,
152             AssetLinkModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
153             "findAll", new String[0]);
154     public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(AssetLinkModelImpl.ENTITY_CACHE_ENABLED,
155             AssetLinkModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
156             "countAll", new String[0]);
157 
158     public void cacheResult(AssetLink assetLink) {
159         EntityCacheUtil.putResult(AssetLinkModelImpl.ENTITY_CACHE_ENABLED,
160             AssetLinkImpl.class, assetLink.getPrimaryKey(), assetLink);
161     }
162 
163     public void cacheResult(List<AssetLink> assetLinks) {
164         for (AssetLink assetLink : assetLinks) {
165             if (EntityCacheUtil.getResult(
166                         AssetLinkModelImpl.ENTITY_CACHE_ENABLED,
167                         AssetLinkImpl.class, assetLink.getPrimaryKey(), this) == null) {
168                 cacheResult(assetLink);
169             }
170         }
171     }
172 
173     public void clearCache() {
174         CacheRegistry.clear(AssetLinkImpl.class.getName());
175         EntityCacheUtil.clearCache(AssetLinkImpl.class.getName());
176         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
177         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
178     }
179 
180     public void clearCache(AssetLink assetLink) {
181         EntityCacheUtil.removeResult(AssetLinkModelImpl.ENTITY_CACHE_ENABLED,
182             AssetLinkImpl.class, assetLink.getPrimaryKey());
183     }
184 
185     public AssetLink create(long linkId) {
186         AssetLink assetLink = new AssetLinkImpl();
187 
188         assetLink.setNew(true);
189         assetLink.setPrimaryKey(linkId);
190 
191         return assetLink;
192     }
193 
194     public AssetLink remove(Serializable primaryKey)
195         throws NoSuchModelException, SystemException {
196         return remove(((Long)primaryKey).longValue());
197     }
198 
199     public AssetLink remove(long linkId)
200         throws NoSuchLinkException, SystemException {
201         Session session = null;
202 
203         try {
204             session = openSession();
205 
206             AssetLink assetLink = (AssetLink)session.get(AssetLinkImpl.class,
207                     new Long(linkId));
208 
209             if (assetLink == null) {
210                 if (_log.isWarnEnabled()) {
211                     _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + linkId);
212                 }
213 
214                 throw new NoSuchLinkException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
215                     linkId);
216             }
217 
218             return remove(assetLink);
219         }
220         catch (NoSuchLinkException nsee) {
221             throw nsee;
222         }
223         catch (Exception e) {
224             throw processException(e);
225         }
226         finally {
227             closeSession(session);
228         }
229     }
230 
231     public AssetLink remove(AssetLink assetLink) throws SystemException {
232         for (ModelListener<AssetLink> listener : listeners) {
233             listener.onBeforeRemove(assetLink);
234         }
235 
236         assetLink = removeImpl(assetLink);
237 
238         for (ModelListener<AssetLink> listener : listeners) {
239             listener.onAfterRemove(assetLink);
240         }
241 
242         return assetLink;
243     }
244 
245     protected AssetLink removeImpl(AssetLink assetLink)
246         throws SystemException {
247         assetLink = toUnwrappedModel(assetLink);
248 
249         Session session = null;
250 
251         try {
252             session = openSession();
253 
254             if (assetLink.isCachedModel() || BatchSessionUtil.isEnabled()) {
255                 Object staleObject = session.get(AssetLinkImpl.class,
256                         assetLink.getPrimaryKeyObj());
257 
258                 if (staleObject != null) {
259                     session.evict(staleObject);
260                 }
261             }
262 
263             session.delete(assetLink);
264 
265             session.flush();
266         }
267         catch (Exception e) {
268             throw processException(e);
269         }
270         finally {
271             closeSession(session);
272         }
273 
274         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
275 
276         EntityCacheUtil.removeResult(AssetLinkModelImpl.ENTITY_CACHE_ENABLED,
277             AssetLinkImpl.class, assetLink.getPrimaryKey());
278 
279         return assetLink;
280     }
281 
282     public AssetLink updateImpl(
283         com.liferay.portlet.asset.model.AssetLink assetLink, boolean merge)
284         throws SystemException {
285         assetLink = toUnwrappedModel(assetLink);
286 
287         Session session = null;
288 
289         try {
290             session = openSession();
291 
292             BatchSessionUtil.update(session, assetLink, merge);
293 
294             assetLink.setNew(false);
295         }
296         catch (Exception e) {
297             throw processException(e);
298         }
299         finally {
300             closeSession(session);
301         }
302 
303         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
304 
305         EntityCacheUtil.putResult(AssetLinkModelImpl.ENTITY_CACHE_ENABLED,
306             AssetLinkImpl.class, assetLink.getPrimaryKey(), assetLink);
307 
308         return assetLink;
309     }
310 
311     protected AssetLink toUnwrappedModel(AssetLink assetLink) {
312         if (assetLink instanceof AssetLinkImpl) {
313             return assetLink;
314         }
315 
316         AssetLinkImpl assetLinkImpl = new AssetLinkImpl();
317 
318         assetLinkImpl.setNew(assetLink.isNew());
319         assetLinkImpl.setPrimaryKey(assetLink.getPrimaryKey());
320 
321         assetLinkImpl.setLinkId(assetLink.getLinkId());
322         assetLinkImpl.setCompanyId(assetLink.getCompanyId());
323         assetLinkImpl.setUserId(assetLink.getUserId());
324         assetLinkImpl.setUserName(assetLink.getUserName());
325         assetLinkImpl.setCreateDate(assetLink.getCreateDate());
326         assetLinkImpl.setEntryId1(assetLink.getEntryId1());
327         assetLinkImpl.setEntryId2(assetLink.getEntryId2());
328         assetLinkImpl.setType(assetLink.getType());
329         assetLinkImpl.setWeight(assetLink.getWeight());
330 
331         return assetLinkImpl;
332     }
333 
334     public AssetLink findByPrimaryKey(Serializable primaryKey)
335         throws NoSuchModelException, SystemException {
336         return findByPrimaryKey(((Long)primaryKey).longValue());
337     }
338 
339     public AssetLink findByPrimaryKey(long linkId)
340         throws NoSuchLinkException, SystemException {
341         AssetLink assetLink = fetchByPrimaryKey(linkId);
342 
343         if (assetLink == null) {
344             if (_log.isWarnEnabled()) {
345                 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + linkId);
346             }
347 
348             throw new NoSuchLinkException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
349                 linkId);
350         }
351 
352         return assetLink;
353     }
354 
355     public AssetLink fetchByPrimaryKey(Serializable primaryKey)
356         throws SystemException {
357         return fetchByPrimaryKey(((Long)primaryKey).longValue());
358     }
359 
360     public AssetLink fetchByPrimaryKey(long linkId) throws SystemException {
361         AssetLink assetLink = (AssetLink)EntityCacheUtil.getResult(AssetLinkModelImpl.ENTITY_CACHE_ENABLED,
362                 AssetLinkImpl.class, linkId, this);
363 
364         if (assetLink == null) {
365             Session session = null;
366 
367             try {
368                 session = openSession();
369 
370                 assetLink = (AssetLink)session.get(AssetLinkImpl.class,
371                         new Long(linkId));
372             }
373             catch (Exception e) {
374                 throw processException(e);
375             }
376             finally {
377                 if (assetLink != null) {
378                     cacheResult(assetLink);
379                 }
380 
381                 closeSession(session);
382             }
383         }
384 
385         return assetLink;
386     }
387 
388     public List<AssetLink> findByE1(long entryId1) throws SystemException {
389         return findByE1(entryId1, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
390     }
391 
392     public List<AssetLink> findByE1(long entryId1, int start, int end)
393         throws SystemException {
394         return findByE1(entryId1, start, end, null);
395     }
396 
397     public List<AssetLink> findByE1(long entryId1, int start, int end,
398         OrderByComparator orderByComparator) throws SystemException {
399         Object[] finderArgs = new Object[] {
400                 new Long(entryId1),
401                 
402                 String.valueOf(start), String.valueOf(end),
403                 String.valueOf(orderByComparator)
404             };
405 
406         List<AssetLink> list = (List<AssetLink>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_E1,
407                 finderArgs, this);
408 
409         if (list == null) {
410             Session session = null;
411 
412             try {
413                 session = openSession();
414 
415                 StringBundler query = null;
416 
417                 if (orderByComparator != null) {
418                     query = new StringBundler(3 +
419                             (orderByComparator.getOrderByFields().length * 3));
420                 }
421                 else {
422                     query = new StringBundler(3);
423                 }
424 
425                 query.append(_SQL_SELECT_ASSETLINK_WHERE);
426 
427                 query.append(_FINDER_COLUMN_E1_ENTRYID1_2);
428 
429                 if (orderByComparator != null) {
430                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
431                         orderByComparator);
432                 }
433 
434                 else {
435                     query.append(AssetLinkModelImpl.ORDER_BY_JPQL);
436                 }
437 
438                 String sql = query.toString();
439 
440                 Query q = session.createQuery(sql);
441 
442                 QueryPos qPos = QueryPos.getInstance(q);
443 
444                 qPos.add(entryId1);
445 
446                 list = (List<AssetLink>)QueryUtil.list(q, getDialect(), start,
447                         end);
448             }
449             catch (Exception e) {
450                 throw processException(e);
451             }
452             finally {
453                 if (list == null) {
454                     list = new ArrayList<AssetLink>();
455                 }
456 
457                 cacheResult(list);
458 
459                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_E1, finderArgs,
460                     list);
461 
462                 closeSession(session);
463             }
464         }
465 
466         return list;
467     }
468 
469     public AssetLink findByE1_First(long entryId1,
470         OrderByComparator orderByComparator)
471         throws NoSuchLinkException, SystemException {
472         List<AssetLink> list = findByE1(entryId1, 0, 1, orderByComparator);
473 
474         if (list.isEmpty()) {
475             StringBundler msg = new StringBundler(4);
476 
477             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
478 
479             msg.append("entryId1=");
480             msg.append(entryId1);
481 
482             msg.append(StringPool.CLOSE_CURLY_BRACE);
483 
484             throw new NoSuchLinkException(msg.toString());
485         }
486         else {
487             return list.get(0);
488         }
489     }
490 
491     public AssetLink findByE1_Last(long entryId1,
492         OrderByComparator orderByComparator)
493         throws NoSuchLinkException, SystemException {
494         int count = countByE1(entryId1);
495 
496         List<AssetLink> list = findByE1(entryId1, count - 1, count,
497                 orderByComparator);
498 
499         if (list.isEmpty()) {
500             StringBundler msg = new StringBundler(4);
501 
502             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
503 
504             msg.append("entryId1=");
505             msg.append(entryId1);
506 
507             msg.append(StringPool.CLOSE_CURLY_BRACE);
508 
509             throw new NoSuchLinkException(msg.toString());
510         }
511         else {
512             return list.get(0);
513         }
514     }
515 
516     public AssetLink[] findByE1_PrevAndNext(long linkId, long entryId1,
517         OrderByComparator orderByComparator)
518         throws NoSuchLinkException, SystemException {
519         AssetLink assetLink = findByPrimaryKey(linkId);
520 
521         Session session = null;
522 
523         try {
524             session = openSession();
525 
526             AssetLink[] array = new AssetLinkImpl[3];
527 
528             array[0] = getByE1_PrevAndNext(session, assetLink, entryId1,
529                     orderByComparator, true);
530 
531             array[1] = assetLink;
532 
533             array[2] = getByE1_PrevAndNext(session, assetLink, entryId1,
534                     orderByComparator, false);
535 
536             return array;
537         }
538         catch (Exception e) {
539             throw processException(e);
540         }
541         finally {
542             closeSession(session);
543         }
544     }
545 
546     protected AssetLink getByE1_PrevAndNext(Session session,
547         AssetLink assetLink, long entryId1,
548         OrderByComparator orderByComparator, boolean previous) {
549         StringBundler query = null;
550 
551         if (orderByComparator != null) {
552             query = new StringBundler(6 +
553                     (orderByComparator.getOrderByFields().length * 6));
554         }
555         else {
556             query = new StringBundler(3);
557         }
558 
559         query.append(_SQL_SELECT_ASSETLINK_WHERE);
560 
561         query.append(_FINDER_COLUMN_E1_ENTRYID1_2);
562 
563         if (orderByComparator != null) {
564             String[] orderByFields = orderByComparator.getOrderByFields();
565 
566             if (orderByFields.length > 0) {
567                 query.append(WHERE_AND);
568             }
569 
570             for (int i = 0; i < orderByFields.length; i++) {
571                 query.append(_ORDER_BY_ENTITY_ALIAS);
572                 query.append(orderByFields[i]);
573 
574                 if ((i + 1) < orderByFields.length) {
575                     if (orderByComparator.isAscending() ^ previous) {
576                         query.append(WHERE_GREATER_THAN_HAS_NEXT);
577                     }
578                     else {
579                         query.append(WHERE_LESSER_THAN_HAS_NEXT);
580                     }
581                 }
582                 else {
583                     if (orderByComparator.isAscending() ^ previous) {
584                         query.append(WHERE_GREATER_THAN);
585                     }
586                     else {
587                         query.append(WHERE_LESSER_THAN);
588                     }
589                 }
590             }
591 
592             query.append(ORDER_BY_CLAUSE);
593 
594             for (int i = 0; i < orderByFields.length; i++) {
595                 query.append(_ORDER_BY_ENTITY_ALIAS);
596                 query.append(orderByFields[i]);
597 
598                 if ((i + 1) < orderByFields.length) {
599                     if (orderByComparator.isAscending() ^ previous) {
600                         query.append(ORDER_BY_ASC_HAS_NEXT);
601                     }
602                     else {
603                         query.append(ORDER_BY_DESC_HAS_NEXT);
604                     }
605                 }
606                 else {
607                     if (orderByComparator.isAscending() ^ previous) {
608                         query.append(ORDER_BY_ASC);
609                     }
610                     else {
611                         query.append(ORDER_BY_DESC);
612                     }
613                 }
614             }
615         }
616 
617         else {
618             query.append(AssetLinkModelImpl.ORDER_BY_JPQL);
619         }
620 
621         String sql = query.toString();
622 
623         Query q = session.createQuery(sql);
624 
625         q.setFirstResult(0);
626         q.setMaxResults(2);
627 
628         QueryPos qPos = QueryPos.getInstance(q);
629 
630         qPos.add(entryId1);
631 
632         if (orderByComparator != null) {
633             Object[] values = orderByComparator.getOrderByValues(assetLink);
634 
635             for (Object value : values) {
636                 qPos.add(value);
637             }
638         }
639 
640         List<AssetLink> list = q.list();
641 
642         if (list.size() == 2) {
643             return list.get(1);
644         }
645         else {
646             return null;
647         }
648     }
649 
650     public List<AssetLink> findByE2(long entryId2) throws SystemException {
651         return findByE2(entryId2, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
652     }
653 
654     public List<AssetLink> findByE2(long entryId2, int start, int end)
655         throws SystemException {
656         return findByE2(entryId2, start, end, null);
657     }
658 
659     public List<AssetLink> findByE2(long entryId2, int start, int end,
660         OrderByComparator orderByComparator) throws SystemException {
661         Object[] finderArgs = new Object[] {
662                 new Long(entryId2),
663                 
664                 String.valueOf(start), String.valueOf(end),
665                 String.valueOf(orderByComparator)
666             };
667 
668         List<AssetLink> list = (List<AssetLink>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_E2,
669                 finderArgs, this);
670 
671         if (list == null) {
672             Session session = null;
673 
674             try {
675                 session = openSession();
676 
677                 StringBundler query = null;
678 
679                 if (orderByComparator != null) {
680                     query = new StringBundler(3 +
681                             (orderByComparator.getOrderByFields().length * 3));
682                 }
683                 else {
684                     query = new StringBundler(3);
685                 }
686 
687                 query.append(_SQL_SELECT_ASSETLINK_WHERE);
688 
689                 query.append(_FINDER_COLUMN_E2_ENTRYID2_2);
690 
691                 if (orderByComparator != null) {
692                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
693                         orderByComparator);
694                 }
695 
696                 else {
697                     query.append(AssetLinkModelImpl.ORDER_BY_JPQL);
698                 }
699 
700                 String sql = query.toString();
701 
702                 Query q = session.createQuery(sql);
703 
704                 QueryPos qPos = QueryPos.getInstance(q);
705 
706                 qPos.add(entryId2);
707 
708                 list = (List<AssetLink>)QueryUtil.list(q, getDialect(), start,
709                         end);
710             }
711             catch (Exception e) {
712                 throw processException(e);
713             }
714             finally {
715                 if (list == null) {
716                     list = new ArrayList<AssetLink>();
717                 }
718 
719                 cacheResult(list);
720 
721                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_E2, finderArgs,
722                     list);
723 
724                 closeSession(session);
725             }
726         }
727 
728         return list;
729     }
730 
731     public AssetLink findByE2_First(long entryId2,
732         OrderByComparator orderByComparator)
733         throws NoSuchLinkException, SystemException {
734         List<AssetLink> list = findByE2(entryId2, 0, 1, orderByComparator);
735 
736         if (list.isEmpty()) {
737             StringBundler msg = new StringBundler(4);
738 
739             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
740 
741             msg.append("entryId2=");
742             msg.append(entryId2);
743 
744             msg.append(StringPool.CLOSE_CURLY_BRACE);
745 
746             throw new NoSuchLinkException(msg.toString());
747         }
748         else {
749             return list.get(0);
750         }
751     }
752 
753     public AssetLink findByE2_Last(long entryId2,
754         OrderByComparator orderByComparator)
755         throws NoSuchLinkException, SystemException {
756         int count = countByE2(entryId2);
757 
758         List<AssetLink> list = findByE2(entryId2, count - 1, count,
759                 orderByComparator);
760 
761         if (list.isEmpty()) {
762             StringBundler msg = new StringBundler(4);
763 
764             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
765 
766             msg.append("entryId2=");
767             msg.append(entryId2);
768 
769             msg.append(StringPool.CLOSE_CURLY_BRACE);
770 
771             throw new NoSuchLinkException(msg.toString());
772         }
773         else {
774             return list.get(0);
775         }
776     }
777 
778     public AssetLink[] findByE2_PrevAndNext(long linkId, long entryId2,
779         OrderByComparator orderByComparator)
780         throws NoSuchLinkException, SystemException {
781         AssetLink assetLink = findByPrimaryKey(linkId);
782 
783         Session session = null;
784 
785         try {
786             session = openSession();
787 
788             AssetLink[] array = new AssetLinkImpl[3];
789 
790             array[0] = getByE2_PrevAndNext(session, assetLink, entryId2,
791                     orderByComparator, true);
792 
793             array[1] = assetLink;
794 
795             array[2] = getByE2_PrevAndNext(session, assetLink, entryId2,
796                     orderByComparator, false);
797 
798             return array;
799         }
800         catch (Exception e) {
801             throw processException(e);
802         }
803         finally {
804             closeSession(session);
805         }
806     }
807 
808     protected AssetLink getByE2_PrevAndNext(Session session,
809         AssetLink assetLink, long entryId2,
810         OrderByComparator orderByComparator, boolean previous) {
811         StringBundler query = null;
812 
813         if (orderByComparator != null) {
814             query = new StringBundler(6 +
815                     (orderByComparator.getOrderByFields().length * 6));
816         }
817         else {
818             query = new StringBundler(3);
819         }
820 
821         query.append(_SQL_SELECT_ASSETLINK_WHERE);
822 
823         query.append(_FINDER_COLUMN_E2_ENTRYID2_2);
824 
825         if (orderByComparator != null) {
826             String[] orderByFields = orderByComparator.getOrderByFields();
827 
828             if (orderByFields.length > 0) {
829                 query.append(WHERE_AND);
830             }
831 
832             for (int i = 0; i < orderByFields.length; i++) {
833                 query.append(_ORDER_BY_ENTITY_ALIAS);
834                 query.append(orderByFields[i]);
835 
836                 if ((i + 1) < orderByFields.length) {
837                     if (orderByComparator.isAscending() ^ previous) {
838                         query.append(WHERE_GREATER_THAN_HAS_NEXT);
839                     }
840                     else {
841                         query.append(WHERE_LESSER_THAN_HAS_NEXT);
842                     }
843                 }
844                 else {
845                     if (orderByComparator.isAscending() ^ previous) {
846                         query.append(WHERE_GREATER_THAN);
847                     }
848                     else {
849                         query.append(WHERE_LESSER_THAN);
850                     }
851                 }
852             }
853 
854             query.append(ORDER_BY_CLAUSE);
855 
856             for (int i = 0; i < orderByFields.length; i++) {
857                 query.append(_ORDER_BY_ENTITY_ALIAS);
858                 query.append(orderByFields[i]);
859 
860                 if ((i + 1) < orderByFields.length) {
861                     if (orderByComparator.isAscending() ^ previous) {
862                         query.append(ORDER_BY_ASC_HAS_NEXT);
863                     }
864                     else {
865                         query.append(ORDER_BY_DESC_HAS_NEXT);
866                     }
867                 }
868                 else {
869                     if (orderByComparator.isAscending() ^ previous) {
870                         query.append(ORDER_BY_ASC);
871                     }
872                     else {
873                         query.append(ORDER_BY_DESC);
874                     }
875                 }
876             }
877         }
878 
879         else {
880             query.append(AssetLinkModelImpl.ORDER_BY_JPQL);
881         }
882 
883         String sql = query.toString();
884 
885         Query q = session.createQuery(sql);
886 
887         q.setFirstResult(0);
888         q.setMaxResults(2);
889 
890         QueryPos qPos = QueryPos.getInstance(q);
891 
892         qPos.add(entryId2);
893 
894         if (orderByComparator != null) {
895             Object[] values = orderByComparator.getOrderByValues(assetLink);
896 
897             for (Object value : values) {
898                 qPos.add(value);
899             }
900         }
901 
902         List<AssetLink> list = q.list();
903 
904         if (list.size() == 2) {
905             return list.get(1);
906         }
907         else {
908             return null;
909         }
910     }
911 
912     public List<AssetLink> findByE_E(long entryId1, long entryId2)
913         throws SystemException {
914         return findByE_E(entryId1, entryId2, QueryUtil.ALL_POS,
915             QueryUtil.ALL_POS, null);
916     }
917 
918     public List<AssetLink> findByE_E(long entryId1, long entryId2, int start,
919         int end) throws SystemException {
920         return findByE_E(entryId1, entryId2, start, end, null);
921     }
922 
923     public List<AssetLink> findByE_E(long entryId1, long entryId2, int start,
924         int end, OrderByComparator orderByComparator) throws SystemException {
925         Object[] finderArgs = new Object[] {
926                 new Long(entryId1), new Long(entryId2),
927                 
928                 String.valueOf(start), String.valueOf(end),
929                 String.valueOf(orderByComparator)
930             };
931 
932         List<AssetLink> list = (List<AssetLink>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_E_E,
933                 finderArgs, this);
934 
935         if (list == null) {
936             Session session = null;
937 
938             try {
939                 session = openSession();
940 
941                 StringBundler query = null;
942 
943                 if (orderByComparator != null) {
944                     query = new StringBundler(4 +
945                             (orderByComparator.getOrderByFields().length * 3));
946                 }
947                 else {
948                     query = new StringBundler(4);
949                 }
950 
951                 query.append(_SQL_SELECT_ASSETLINK_WHERE);
952 
953                 query.append(_FINDER_COLUMN_E_E_ENTRYID1_2);
954 
955                 query.append(_FINDER_COLUMN_E_E_ENTRYID2_2);
956 
957                 if (orderByComparator != null) {
958                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
959                         orderByComparator);
960                 }
961 
962                 else {
963                     query.append(AssetLinkModelImpl.ORDER_BY_JPQL);
964                 }
965 
966                 String sql = query.toString();
967 
968                 Query q = session.createQuery(sql);
969 
970                 QueryPos qPos = QueryPos.getInstance(q);
971 
972                 qPos.add(entryId1);
973 
974                 qPos.add(entryId2);
975 
976                 list = (List<AssetLink>)QueryUtil.list(q, getDialect(), start,
977                         end);
978             }
979             catch (Exception e) {
980                 throw processException(e);
981             }
982             finally {
983                 if (list == null) {
984                     list = new ArrayList<AssetLink>();
985                 }
986 
987                 cacheResult(list);
988 
989                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_E_E, finderArgs,
990                     list);
991 
992                 closeSession(session);
993             }
994         }
995 
996         return list;
997     }
998 
999     public AssetLink findByE_E_First(long entryId1, long entryId2,
1000        OrderByComparator orderByComparator)
1001        throws NoSuchLinkException, SystemException {
1002        List<AssetLink> list = findByE_E(entryId1, entryId2, 0, 1,
1003                orderByComparator);
1004
1005        if (list.isEmpty()) {
1006            StringBundler msg = new StringBundler(6);
1007
1008            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1009
1010            msg.append("entryId1=");
1011            msg.append(entryId1);
1012
1013            msg.append(", entryId2=");
1014            msg.append(entryId2);
1015
1016            msg.append(StringPool.CLOSE_CURLY_BRACE);
1017
1018            throw new NoSuchLinkException(msg.toString());
1019        }
1020        else {
1021            return list.get(0);
1022        }
1023    }
1024
1025    public AssetLink findByE_E_Last(long entryId1, long entryId2,
1026        OrderByComparator orderByComparator)
1027        throws NoSuchLinkException, SystemException {
1028        int count = countByE_E(entryId1, entryId2);
1029
1030        List<AssetLink> list = findByE_E(entryId1, entryId2, count - 1, count,
1031                orderByComparator);
1032
1033        if (list.isEmpty()) {
1034            StringBundler msg = new StringBundler(6);
1035
1036            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1037
1038            msg.append("entryId1=");
1039            msg.append(entryId1);
1040
1041            msg.append(", entryId2=");
1042            msg.append(entryId2);
1043
1044            msg.append(StringPool.CLOSE_CURLY_BRACE);
1045
1046            throw new NoSuchLinkException(msg.toString());
1047        }
1048        else {
1049            return list.get(0);
1050        }
1051    }
1052
1053    public AssetLink[] findByE_E_PrevAndNext(long linkId, long entryId1,
1054        long entryId2, OrderByComparator orderByComparator)
1055        throws NoSuchLinkException, SystemException {
1056        AssetLink assetLink = findByPrimaryKey(linkId);
1057
1058        Session session = null;
1059
1060        try {
1061            session = openSession();
1062
1063            AssetLink[] array = new AssetLinkImpl[3];
1064
1065            array[0] = getByE_E_PrevAndNext(session, assetLink, entryId1,
1066                    entryId2, orderByComparator, true);
1067
1068            array[1] = assetLink;
1069
1070            array[2] = getByE_E_PrevAndNext(session, assetLink, entryId1,
1071                    entryId2, orderByComparator, false);
1072
1073            return array;
1074        }
1075        catch (Exception e) {
1076            throw processException(e);
1077        }
1078        finally {
1079            closeSession(session);
1080        }
1081    }
1082
1083    protected AssetLink getByE_E_PrevAndNext(Session session,
1084        AssetLink assetLink, long entryId1, long entryId2,
1085        OrderByComparator orderByComparator, boolean previous) {
1086        StringBundler query = null;
1087
1088        if (orderByComparator != null) {
1089            query = new StringBundler(6 +
1090                    (orderByComparator.getOrderByFields().length * 6));
1091        }
1092        else {
1093            query = new StringBundler(3);
1094        }
1095
1096        query.append(_SQL_SELECT_ASSETLINK_WHERE);
1097
1098        query.append(_FINDER_COLUMN_E_E_ENTRYID1_2);
1099
1100        query.append(_FINDER_COLUMN_E_E_ENTRYID2_2);
1101
1102        if (orderByComparator != null) {
1103            String[] orderByFields = orderByComparator.getOrderByFields();
1104
1105            if (orderByFields.length > 0) {
1106                query.append(WHERE_AND);
1107            }
1108
1109            for (int i = 0; i < orderByFields.length; i++) {
1110                query.append(_ORDER_BY_ENTITY_ALIAS);
1111                query.append(orderByFields[i]);
1112
1113                if ((i + 1) < orderByFields.length) {
1114                    if (orderByComparator.isAscending() ^ previous) {
1115                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
1116                    }
1117                    else {
1118                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
1119                    }
1120                }
1121                else {
1122                    if (orderByComparator.isAscending() ^ previous) {
1123                        query.append(WHERE_GREATER_THAN);
1124                    }
1125                    else {
1126                        query.append(WHERE_LESSER_THAN);
1127                    }
1128                }
1129            }
1130
1131            query.append(ORDER_BY_CLAUSE);
1132
1133            for (int i = 0; i < orderByFields.length; i++) {
1134                query.append(_ORDER_BY_ENTITY_ALIAS);
1135                query.append(orderByFields[i]);
1136
1137                if ((i + 1) < orderByFields.length) {
1138                    if (orderByComparator.isAscending() ^ previous) {
1139                        query.append(ORDER_BY_ASC_HAS_NEXT);
1140                    }
1141                    else {
1142                        query.append(ORDER_BY_DESC_HAS_NEXT);
1143                    }
1144                }
1145                else {
1146                    if (orderByComparator.isAscending() ^ previous) {
1147                        query.append(ORDER_BY_ASC);
1148                    }
1149                    else {
1150                        query.append(ORDER_BY_DESC);
1151                    }
1152                }
1153            }
1154        }
1155
1156        else {
1157            query.append(AssetLinkModelImpl.ORDER_BY_JPQL);
1158        }
1159
1160        String sql = query.toString();
1161
1162        Query q = session.createQuery(sql);
1163
1164        q.setFirstResult(0);
1165        q.setMaxResults(2);
1166
1167        QueryPos qPos = QueryPos.getInstance(q);
1168
1169        qPos.add(entryId1);
1170
1171        qPos.add(entryId2);
1172
1173        if (orderByComparator != null) {
1174            Object[] values = orderByComparator.getOrderByValues(assetLink);
1175
1176            for (Object value : values) {
1177                qPos.add(value);
1178            }
1179        }
1180
1181        List<AssetLink> list = q.list();
1182
1183        if (list.size() == 2) {
1184            return list.get(1);
1185        }
1186        else {
1187            return null;
1188        }
1189    }
1190
1191    public List<AssetLink> findByE1_T(long entryId1, int type)
1192        throws SystemException {
1193        return findByE1_T(entryId1, type, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
1194            null);
1195    }
1196
1197    public List<AssetLink> findByE1_T(long entryId1, int type, int start,
1198        int end) throws SystemException {
1199        return findByE1_T(entryId1, type, start, end, null);
1200    }
1201
1202    public List<AssetLink> findByE1_T(long entryId1, int type, int start,
1203        int end, OrderByComparator orderByComparator) throws SystemException {
1204        Object[] finderArgs = new Object[] {
1205                new Long(entryId1), new Integer(type),
1206                
1207                String.valueOf(start), String.valueOf(end),
1208                String.valueOf(orderByComparator)
1209            };
1210
1211        List<AssetLink> list = (List<AssetLink>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_E1_T,
1212                finderArgs, this);
1213
1214        if (list == null) {
1215            Session session = null;
1216
1217            try {
1218                session = openSession();
1219
1220                StringBundler query = null;
1221
1222                if (orderByComparator != null) {
1223                    query = new StringBundler(4 +
1224                            (orderByComparator.getOrderByFields().length * 3));
1225                }
1226                else {
1227                    query = new StringBundler(4);
1228                }
1229
1230                query.append(_SQL_SELECT_ASSETLINK_WHERE);
1231
1232                query.append(_FINDER_COLUMN_E1_T_ENTRYID1_2);
1233
1234                query.append(_FINDER_COLUMN_E1_T_TYPE_2);
1235
1236                if (orderByComparator != null) {
1237                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1238                        orderByComparator);
1239                }
1240
1241                else {
1242                    query.append(AssetLinkModelImpl.ORDER_BY_JPQL);
1243                }
1244
1245                String sql = query.toString();
1246
1247                Query q = session.createQuery(sql);
1248
1249                QueryPos qPos = QueryPos.getInstance(q);
1250
1251                qPos.add(entryId1);
1252
1253                qPos.add(type);
1254
1255                list = (List<AssetLink>)QueryUtil.list(q, getDialect(), start,
1256                        end);
1257            }
1258            catch (Exception e) {
1259                throw processException(e);
1260            }
1261            finally {
1262                if (list == null) {
1263                    list = new ArrayList<AssetLink>();
1264                }
1265
1266                cacheResult(list);
1267
1268                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_E1_T, finderArgs,
1269                    list);
1270
1271                closeSession(session);
1272            }
1273        }
1274
1275        return list;
1276    }
1277
1278    public AssetLink findByE1_T_First(long entryId1, int type,
1279        OrderByComparator orderByComparator)
1280        throws NoSuchLinkException, SystemException {
1281        List<AssetLink> list = findByE1_T(entryId1, type, 0, 1,
1282                orderByComparator);
1283
1284        if (list.isEmpty()) {
1285            StringBundler msg = new StringBundler(6);
1286
1287            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1288
1289            msg.append("entryId1=");
1290            msg.append(entryId1);
1291
1292            msg.append(", type=");
1293            msg.append(type);
1294
1295            msg.append(StringPool.CLOSE_CURLY_BRACE);
1296
1297            throw new NoSuchLinkException(msg.toString());
1298        }
1299        else {
1300            return list.get(0);
1301        }
1302    }
1303
1304    public AssetLink findByE1_T_Last(long entryId1, int type,
1305        OrderByComparator orderByComparator)
1306        throws NoSuchLinkException, SystemException {
1307        int count = countByE1_T(entryId1, type);
1308
1309        List<AssetLink> list = findByE1_T(entryId1, type, count - 1, count,
1310                orderByComparator);
1311
1312        if (list.isEmpty()) {
1313            StringBundler msg = new StringBundler(6);
1314
1315            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1316
1317            msg.append("entryId1=");
1318            msg.append(entryId1);
1319
1320            msg.append(", type=");
1321            msg.append(type);
1322
1323            msg.append(StringPool.CLOSE_CURLY_BRACE);
1324
1325            throw new NoSuchLinkException(msg.toString());
1326        }
1327        else {
1328            return list.get(0);
1329        }
1330    }
1331
1332    public AssetLink[] findByE1_T_PrevAndNext(long linkId, long entryId1,
1333        int type, OrderByComparator orderByComparator)
1334        throws NoSuchLinkException, SystemException {
1335        AssetLink assetLink = findByPrimaryKey(linkId);
1336
1337        Session session = null;
1338
1339        try {
1340            session = openSession();
1341
1342            AssetLink[] array = new AssetLinkImpl[3];
1343
1344            array[0] = getByE1_T_PrevAndNext(session, assetLink, entryId1,
1345                    type, orderByComparator, true);
1346
1347            array[1] = assetLink;
1348
1349            array[2] = getByE1_T_PrevAndNext(session, assetLink, entryId1,
1350                    type, orderByComparator, false);
1351
1352            return array;
1353        }
1354        catch (Exception e) {
1355            throw processException(e);
1356        }
1357        finally {
1358            closeSession(session);
1359        }
1360    }
1361
1362    protected AssetLink getByE1_T_PrevAndNext(Session session,
1363        AssetLink assetLink, long entryId1, int type,
1364        OrderByComparator orderByComparator, boolean previous) {
1365        StringBundler query = null;
1366
1367        if (orderByComparator != null) {
1368            query = new StringBundler(6 +
1369                    (orderByComparator.getOrderByFields().length * 6));
1370        }
1371        else {
1372            query = new StringBundler(3);
1373        }
1374
1375        query.append(_SQL_SELECT_ASSETLINK_WHERE);
1376
1377        query.append(_FINDER_COLUMN_E1_T_ENTRYID1_2);
1378
1379        query.append(_FINDER_COLUMN_E1_T_TYPE_2);
1380
1381        if (orderByComparator != null) {
1382            String[] orderByFields = orderByComparator.getOrderByFields();
1383
1384            if (orderByFields.length > 0) {
1385                query.append(WHERE_AND);
1386            }
1387
1388            for (int i = 0; i < orderByFields.length; i++) {
1389                query.append(_ORDER_BY_ENTITY_ALIAS);
1390                query.append(orderByFields[i]);
1391
1392                if ((i + 1) < orderByFields.length) {
1393                    if (orderByComparator.isAscending() ^ previous) {
1394                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
1395                    }
1396                    else {
1397                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
1398                    }
1399                }
1400                else {
1401                    if (orderByComparator.isAscending() ^ previous) {
1402                        query.append(WHERE_GREATER_THAN);
1403                    }
1404                    else {
1405                        query.append(WHERE_LESSER_THAN);
1406                    }
1407                }
1408            }
1409
1410            query.append(ORDER_BY_CLAUSE);
1411
1412            for (int i = 0; i < orderByFields.length; i++) {
1413                query.append(_ORDER_BY_ENTITY_ALIAS);
1414                query.append(orderByFields[i]);
1415
1416                if ((i + 1) < orderByFields.length) {
1417                    if (orderByComparator.isAscending() ^ previous) {
1418                        query.append(ORDER_BY_ASC_HAS_NEXT);
1419                    }
1420                    else {
1421                        query.append(ORDER_BY_DESC_HAS_NEXT);
1422                    }
1423                }
1424                else {
1425                    if (orderByComparator.isAscending() ^ previous) {
1426                        query.append(ORDER_BY_ASC);
1427                    }
1428                    else {
1429                        query.append(ORDER_BY_DESC);
1430                    }
1431                }
1432            }
1433        }
1434
1435        else {
1436            query.append(AssetLinkModelImpl.ORDER_BY_JPQL);
1437        }
1438
1439        String sql = query.toString();
1440
1441        Query q = session.createQuery(sql);
1442
1443        q.setFirstResult(0);
1444        q.setMaxResults(2);
1445
1446        QueryPos qPos = QueryPos.getInstance(q);
1447
1448        qPos.add(entryId1);
1449
1450        qPos.add(type);
1451
1452        if (orderByComparator != null) {
1453            Object[] values = orderByComparator.getOrderByValues(assetLink);
1454
1455            for (Object value : values) {
1456                qPos.add(value);
1457            }
1458        }
1459
1460        List<AssetLink> list = q.list();
1461
1462        if (list.size() == 2) {
1463            return list.get(1);
1464        }
1465        else {
1466            return null;
1467        }
1468    }
1469
1470    public List<AssetLink> findByE2_T(long entryId2, int type)
1471        throws SystemException {
1472        return findByE2_T(entryId2, type, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
1473            null);
1474    }
1475
1476    public List<AssetLink> findByE2_T(long entryId2, int type, int start,
1477        int end) throws SystemException {
1478        return findByE2_T(entryId2, type, start, end, null);
1479    }
1480
1481    public List<AssetLink> findByE2_T(long entryId2, int type, int start,
1482        int end, OrderByComparator orderByComparator) throws SystemException {
1483        Object[] finderArgs = new Object[] {
1484                new Long(entryId2), new Integer(type),
1485                
1486                String.valueOf(start), String.valueOf(end),
1487                String.valueOf(orderByComparator)
1488            };
1489
1490        List<AssetLink> list = (List<AssetLink>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_E2_T,
1491                finderArgs, this);
1492
1493        if (list == null) {
1494            Session session = null;
1495
1496            try {
1497                session = openSession();
1498
1499                StringBundler query = null;
1500
1501                if (orderByComparator != null) {
1502                    query = new StringBundler(4 +
1503                            (orderByComparator.getOrderByFields().length * 3));
1504                }
1505                else {
1506                    query = new StringBundler(4);
1507                }
1508
1509                query.append(_SQL_SELECT_ASSETLINK_WHERE);
1510
1511                query.append(_FINDER_COLUMN_E2_T_ENTRYID2_2);
1512
1513                query.append(_FINDER_COLUMN_E2_T_TYPE_2);
1514
1515                if (orderByComparator != null) {
1516                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1517                        orderByComparator);
1518                }
1519
1520                else {
1521                    query.append(AssetLinkModelImpl.ORDER_BY_JPQL);
1522                }
1523
1524                String sql = query.toString();
1525
1526                Query q = session.createQuery(sql);
1527
1528                QueryPos qPos = QueryPos.getInstance(q);
1529
1530                qPos.add(entryId2);
1531
1532                qPos.add(type);
1533
1534                list = (List<AssetLink>)QueryUtil.list(q, getDialect(), start,
1535                        end);
1536            }
1537            catch (Exception e) {
1538                throw processException(e);
1539            }
1540            finally {
1541                if (list == null) {
1542                    list = new ArrayList<AssetLink>();
1543                }
1544
1545                cacheResult(list);
1546
1547                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_E2_T, finderArgs,
1548                    list);
1549
1550                closeSession(session);
1551            }
1552        }
1553
1554        return list;
1555    }
1556
1557    public AssetLink findByE2_T_First(long entryId2, int type,
1558        OrderByComparator orderByComparator)
1559        throws NoSuchLinkException, SystemException {
1560        List<AssetLink> list = findByE2_T(entryId2, type, 0, 1,
1561                orderByComparator);
1562
1563        if (list.isEmpty()) {
1564            StringBundler msg = new StringBundler(6);
1565
1566            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1567
1568            msg.append("entryId2=");
1569            msg.append(entryId2);
1570
1571            msg.append(", type=");
1572            msg.append(type);
1573
1574            msg.append(StringPool.CLOSE_CURLY_BRACE);
1575
1576            throw new NoSuchLinkException(msg.toString());
1577        }
1578        else {
1579            return list.get(0);
1580        }
1581    }
1582
1583    public AssetLink findByE2_T_Last(long entryId2, int type,
1584        OrderByComparator orderByComparator)
1585        throws NoSuchLinkException, SystemException {
1586        int count = countByE2_T(entryId2, type);
1587
1588        List<AssetLink> list = findByE2_T(entryId2, type, count - 1, count,
1589                orderByComparator);
1590
1591        if (list.isEmpty()) {
1592            StringBundler msg = new StringBundler(6);
1593
1594            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1595
1596            msg.append("entryId2=");
1597            msg.append(entryId2);
1598
1599            msg.append(", type=");
1600            msg.append(type);
1601
1602            msg.append(StringPool.CLOSE_CURLY_BRACE);
1603
1604            throw new NoSuchLinkException(msg.toString());
1605        }
1606        else {
1607            return list.get(0);
1608        }
1609    }
1610
1611    public AssetLink[] findByE2_T_PrevAndNext(long linkId, long entryId2,
1612        int type, OrderByComparator orderByComparator)
1613        throws NoSuchLinkException, SystemException {
1614        AssetLink assetLink = findByPrimaryKey(linkId);
1615
1616        Session session = null;
1617
1618        try {
1619            session = openSession();
1620
1621            AssetLink[] array = new AssetLinkImpl[3];
1622
1623            array[0] = getByE2_T_PrevAndNext(session, assetLink, entryId2,
1624                    type, orderByComparator, true);
1625
1626            array[1] = assetLink;
1627
1628            array[2] = getByE2_T_PrevAndNext(session, assetLink, entryId2,
1629                    type, orderByComparator, false);
1630
1631            return array;
1632        }
1633        catch (Exception e) {
1634            throw processException(e);
1635        }
1636        finally {
1637            closeSession(session);
1638        }
1639    }
1640
1641    protected AssetLink getByE2_T_PrevAndNext(Session session,
1642        AssetLink assetLink, long entryId2, int type,
1643        OrderByComparator orderByComparator, boolean previous) {
1644        StringBundler query = null;
1645
1646        if (orderByComparator != null) {
1647            query = new StringBundler(6 +
1648                    (orderByComparator.getOrderByFields().length * 6));
1649        }
1650        else {
1651            query = new StringBundler(3);
1652        }
1653
1654        query.append(_SQL_SELECT_ASSETLINK_WHERE);
1655
1656        query.append(_FINDER_COLUMN_E2_T_ENTRYID2_2);
1657
1658        query.append(_FINDER_COLUMN_E2_T_TYPE_2);
1659
1660        if (orderByComparator != null) {
1661            String[] orderByFields = orderByComparator.getOrderByFields();
1662
1663            if (orderByFields.length > 0) {
1664                query.append(WHERE_AND);
1665            }
1666
1667            for (int i = 0; i < orderByFields.length; i++) {
1668                query.append(_ORDER_BY_ENTITY_ALIAS);
1669                query.append(orderByFields[i]);
1670
1671                if ((i + 1) < orderByFields.length) {
1672                    if (orderByComparator.isAscending() ^ previous) {
1673                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
1674                    }
1675                    else {
1676                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
1677                    }
1678                }
1679                else {
1680                    if (orderByComparator.isAscending() ^ previous) {
1681                        query.append(WHERE_GREATER_THAN);
1682                    }
1683                    else {
1684                        query.append(WHERE_LESSER_THAN);
1685                    }
1686                }
1687            }
1688
1689            query.append(ORDER_BY_CLAUSE);
1690
1691            for (int i = 0; i < orderByFields.length; i++) {
1692                query.append(_ORDER_BY_ENTITY_ALIAS);
1693                query.append(orderByFields[i]);
1694
1695                if ((i + 1) < orderByFields.length) {
1696                    if (orderByComparator.isAscending() ^ previous) {
1697                        query.append(ORDER_BY_ASC_HAS_NEXT);
1698                    }
1699                    else {
1700                        query.append(ORDER_BY_DESC_HAS_NEXT);
1701                    }
1702                }
1703                else {
1704                    if (orderByComparator.isAscending() ^ previous) {
1705                        query.append(ORDER_BY_ASC);
1706                    }
1707                    else {
1708                        query.append(ORDER_BY_DESC);
1709                    }
1710                }
1711            }
1712        }
1713
1714        else {
1715            query.append(AssetLinkModelImpl.ORDER_BY_JPQL);
1716        }
1717
1718        String sql = query.toString();
1719
1720        Query q = session.createQuery(sql);
1721
1722        q.setFirstResult(0);
1723        q.setMaxResults(2);
1724
1725        QueryPos qPos = QueryPos.getInstance(q);
1726
1727        qPos.add(entryId2);
1728
1729        qPos.add(type);
1730
1731        if (orderByComparator != null) {
1732            Object[] values = orderByComparator.getOrderByValues(assetLink);
1733
1734            for (Object value : values) {
1735                qPos.add(value);
1736            }
1737        }
1738
1739        List<AssetLink> list = q.list();
1740
1741        if (list.size() == 2) {
1742            return list.get(1);
1743        }
1744        else {
1745            return null;
1746        }
1747    }
1748
1749    public List<AssetLink> findByE_E_T(long entryId1, long entryId2, int type)
1750        throws SystemException {
1751        return findByE_E_T(entryId1, entryId2, type, QueryUtil.ALL_POS,
1752            QueryUtil.ALL_POS, null);
1753    }
1754
1755    public List<AssetLink> findByE_E_T(long entryId1, long entryId2, int type,
1756        int start, int end) throws SystemException {
1757        return findByE_E_T(entryId1, entryId2, type, start, end, null);
1758    }
1759
1760    public List<AssetLink> findByE_E_T(long entryId1, long entryId2, int type,
1761        int start, int end, OrderByComparator orderByComparator)
1762        throws SystemException {
1763        Object[] finderArgs = new Object[] {
1764                new Long(entryId1), new Long(entryId2), new Integer(type),
1765                
1766                String.valueOf(start), String.valueOf(end),
1767                String.valueOf(orderByComparator)
1768            };
1769
1770        List<AssetLink> list = (List<AssetLink>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_E_E_T,
1771                finderArgs, this);
1772
1773        if (list == null) {
1774            Session session = null;
1775
1776            try {
1777                session = openSession();
1778
1779                StringBundler query = null;
1780
1781                if (orderByComparator != null) {
1782                    query = new StringBundler(5 +
1783                            (orderByComparator.getOrderByFields().length * 3));
1784                }
1785                else {
1786                    query = new StringBundler(5);
1787                }
1788
1789                query.append(_SQL_SELECT_ASSETLINK_WHERE);
1790
1791                query.append(_FINDER_COLUMN_E_E_T_ENTRYID1_2);
1792
1793                query.append(_FINDER_COLUMN_E_E_T_ENTRYID2_2);
1794
1795                query.append(_FINDER_COLUMN_E_E_T_TYPE_2);
1796
1797                if (orderByComparator != null) {
1798                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1799                        orderByComparator);
1800                }
1801
1802                else {
1803                    query.append(AssetLinkModelImpl.ORDER_BY_JPQL);
1804                }
1805
1806                String sql = query.toString();
1807
1808                Query q = session.createQuery(sql);
1809
1810                QueryPos qPos = QueryPos.getInstance(q);
1811
1812                qPos.add(entryId1);
1813
1814                qPos.add(entryId2);
1815
1816                qPos.add(type);
1817
1818                list = (List<AssetLink>)QueryUtil.list(q, getDialect(), start,
1819                        end);
1820            }
1821            catch (Exception e) {
1822                throw processException(e);
1823            }
1824            finally {
1825                if (list == null) {
1826                    list = new ArrayList<AssetLink>();
1827                }
1828
1829                cacheResult(list);
1830
1831                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_E_E_T,
1832                    finderArgs, list);
1833
1834                closeSession(session);
1835            }
1836        }
1837
1838        return list;
1839    }
1840
1841    public AssetLink findByE_E_T_First(long entryId1, long entryId2, int type,
1842        OrderByComparator orderByComparator)
1843        throws NoSuchLinkException, SystemException {
1844        List<AssetLink> list = findByE_E_T(entryId1, entryId2, type, 0, 1,
1845                orderByComparator);
1846
1847        if (list.isEmpty()) {
1848            StringBundler msg = new StringBundler(8);
1849
1850            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1851
1852            msg.append("entryId1=");
1853            msg.append(entryId1);
1854
1855            msg.append(", entryId2=");
1856            msg.append(entryId2);
1857
1858            msg.append(", type=");
1859            msg.append(type);
1860
1861            msg.append(StringPool.CLOSE_CURLY_BRACE);
1862
1863            throw new NoSuchLinkException(msg.toString());
1864        }
1865        else {
1866            return list.get(0);
1867        }
1868    }
1869
1870    public AssetLink findByE_E_T_Last(long entryId1, long entryId2, int type,
1871        OrderByComparator orderByComparator)
1872        throws NoSuchLinkException, SystemException {
1873        int count = countByE_E_T(entryId1, entryId2, type);
1874
1875        List<AssetLink> list = findByE_E_T(entryId1, entryId2, type, count - 1,
1876                count, orderByComparator);
1877
1878        if (list.isEmpty()) {
1879            StringBundler msg = new StringBundler(8);
1880
1881            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1882
1883            msg.append("entryId1=");
1884            msg.append(entryId1);
1885
1886            msg.append(", entryId2=");
1887            msg.append(entryId2);
1888
1889            msg.append(", type=");
1890            msg.append(type);
1891
1892            msg.append(StringPool.CLOSE_CURLY_BRACE);
1893
1894            throw new NoSuchLinkException(msg.toString());
1895        }
1896        else {
1897            return list.get(0);
1898        }
1899    }
1900
1901    public AssetLink[] findByE_E_T_PrevAndNext(long linkId, long entryId1,
1902        long entryId2, int type, OrderByComparator orderByComparator)
1903        throws NoSuchLinkException, SystemException {
1904        AssetLink assetLink = findByPrimaryKey(linkId);
1905
1906        Session session = null;
1907
1908        try {
1909            session = openSession();
1910
1911            AssetLink[] array = new AssetLinkImpl[3];
1912
1913            array[0] = getByE_E_T_PrevAndNext(session, assetLink, entryId1,
1914                    entryId2, type, orderByComparator, true);
1915
1916            array[1] = assetLink;
1917
1918            array[2] = getByE_E_T_PrevAndNext(session, assetLink, entryId1,
1919                    entryId2, type, orderByComparator, false);
1920
1921            return array;
1922        }
1923        catch (Exception e) {
1924            throw processException(e);
1925        }
1926        finally {
1927            closeSession(session);
1928        }
1929    }
1930
1931    protected AssetLink getByE_E_T_PrevAndNext(Session session,
1932        AssetLink assetLink, long entryId1, long entryId2, int type,
1933        OrderByComparator orderByComparator, boolean previous) {
1934        StringBundler query = null;
1935
1936        if (orderByComparator != null) {
1937            query = new StringBundler(6 +
1938                    (orderByComparator.getOrderByFields().length * 6));
1939        }
1940        else {
1941            query = new StringBundler(3);
1942        }
1943
1944        query.append(_SQL_SELECT_ASSETLINK_WHERE);
1945
1946        query.append(_FINDER_COLUMN_E_E_T_ENTRYID1_2);
1947
1948        query.append(_FINDER_COLUMN_E_E_T_ENTRYID2_2);
1949
1950        query.append(_FINDER_COLUMN_E_E_T_TYPE_2);
1951
1952        if (orderByComparator != null) {
1953            String[] orderByFields = orderByComparator.getOrderByFields();
1954
1955            if (orderByFields.length > 0) {
1956                query.append(WHERE_AND);
1957            }
1958
1959            for (int i = 0; i < orderByFields.length; i++) {
1960                query.append(_ORDER_BY_ENTITY_ALIAS);
1961                query.append(orderByFields[i]);
1962
1963                if ((i + 1) < orderByFields.length) {
1964                    if (orderByComparator.isAscending() ^ previous) {
1965                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
1966                    }
1967                    else {
1968                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
1969                    }
1970                }
1971                else {
1972                    if (orderByComparator.isAscending() ^ previous) {
1973                        query.append(WHERE_GREATER_THAN);
1974                    }
1975                    else {
1976                        query.append(WHERE_LESSER_THAN);
1977                    }
1978                }
1979            }
1980
1981            query.append(ORDER_BY_CLAUSE);
1982
1983            for (int i = 0; i < orderByFields.length; i++) {
1984                query.append(_ORDER_BY_ENTITY_ALIAS);
1985                query.append(orderByFields[i]);
1986
1987                if ((i + 1) < orderByFields.length) {
1988                    if (orderByComparator.isAscending() ^ previous) {
1989                        query.append(ORDER_BY_ASC_HAS_NEXT);
1990                    }
1991                    else {
1992                        query.append(ORDER_BY_DESC_HAS_NEXT);
1993                    }
1994                }
1995                else {
1996                    if (orderByComparator.isAscending() ^ previous) {
1997                        query.append(ORDER_BY_ASC);
1998                    }
1999                    else {
2000                        query.append(ORDER_BY_DESC);
2001                    }
2002                }
2003            }
2004        }
2005
2006        else {
2007            query.append(AssetLinkModelImpl.ORDER_BY_JPQL);
2008        }
2009
2010        String sql = query.toString();
2011
2012        Query q = session.createQuery(sql);
2013
2014        q.setFirstResult(0);
2015        q.setMaxResults(2);
2016
2017        QueryPos qPos = QueryPos.getInstance(q);
2018
2019        qPos.add(entryId1);
2020
2021        qPos.add(entryId2);
2022
2023        qPos.add(type);
2024
2025        if (orderByComparator != null) {
2026            Object[] values = orderByComparator.getOrderByValues(assetLink);
2027
2028            for (Object value : values) {
2029                qPos.add(value);
2030            }
2031        }
2032
2033        List<AssetLink> list = q.list();
2034
2035        if (list.size() == 2) {
2036            return list.get(1);
2037        }
2038        else {
2039            return null;
2040        }
2041    }
2042
2043    public List<AssetLink> findAll() throws SystemException {
2044        return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
2045    }
2046
2047    public List<AssetLink> findAll(int start, int end)
2048        throws SystemException {
2049        return findAll(start, end, null);
2050    }
2051
2052    public List<AssetLink> findAll(int start, int end,
2053        OrderByComparator orderByComparator) throws SystemException {
2054        Object[] finderArgs = new Object[] {
2055                String.valueOf(start), String.valueOf(end),
2056                String.valueOf(orderByComparator)
2057            };
2058
2059        List<AssetLink> list = (List<AssetLink>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
2060                finderArgs, this);
2061
2062        if (list == null) {
2063            Session session = null;
2064
2065            try {
2066                session = openSession();
2067
2068                StringBundler query = null;
2069                String sql = null;
2070
2071                if (orderByComparator != null) {
2072                    query = new StringBundler(2 +
2073                            (orderByComparator.getOrderByFields().length * 3));
2074
2075                    query.append(_SQL_SELECT_ASSETLINK);
2076
2077                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2078                        orderByComparator);
2079
2080                    sql = query.toString();
2081                }
2082
2083                else {
2084                    sql = _SQL_SELECT_ASSETLINK.concat(AssetLinkModelImpl.ORDER_BY_JPQL);
2085                }
2086
2087                Query q = session.createQuery(sql);
2088
2089                if (orderByComparator == null) {
2090                    list = (List<AssetLink>)QueryUtil.list(q, getDialect(),
2091                            start, end, false);
2092
2093                    Collections.sort(list);
2094                }
2095                else {
2096                    list = (List<AssetLink>)QueryUtil.list(q, getDialect(),
2097                            start, end);
2098                }
2099            }
2100            catch (Exception e) {
2101                throw processException(e);
2102            }
2103            finally {
2104                if (list == null) {
2105                    list = new ArrayList<AssetLink>();
2106                }
2107
2108                cacheResult(list);
2109
2110                FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
2111
2112                closeSession(session);
2113            }
2114        }
2115
2116        return list;
2117    }
2118
2119    public void removeByE1(long entryId1) throws SystemException {
2120        for (AssetLink assetLink : findByE1(entryId1)) {
2121            remove(assetLink);
2122        }
2123    }
2124
2125    public void removeByE2(long entryId2) throws SystemException {
2126        for (AssetLink assetLink : findByE2(entryId2)) {
2127            remove(assetLink);
2128        }
2129    }
2130
2131    public void removeByE_E(long entryId1, long entryId2)
2132        throws SystemException {
2133        for (AssetLink assetLink : findByE_E(entryId1, entryId2)) {
2134            remove(assetLink);
2135        }
2136    }
2137
2138    public void removeByE1_T(long entryId1, int type) throws SystemException {
2139        for (AssetLink assetLink : findByE1_T(entryId1, type)) {
2140            remove(assetLink);
2141        }
2142    }
2143
2144    public void removeByE2_T(long entryId2, int type) throws SystemException {
2145        for (AssetLink assetLink : findByE2_T(entryId2, type)) {
2146            remove(assetLink);
2147        }
2148    }
2149
2150    public void removeByE_E_T(long entryId1, long entryId2, int type)
2151        throws SystemException {
2152        for (AssetLink assetLink : findByE_E_T(entryId1, entryId2, type)) {
2153            remove(assetLink);
2154        }
2155    }
2156
2157    public void removeAll() throws SystemException {
2158        for (AssetLink assetLink : findAll()) {
2159            remove(assetLink);
2160        }
2161    }
2162
2163    public int countByE1(long entryId1) throws SystemException {
2164        Object[] finderArgs = new Object[] { new Long(entryId1) };
2165
2166        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_E1,
2167                finderArgs, this);
2168
2169        if (count == null) {
2170            Session session = null;
2171
2172            try {
2173                session = openSession();
2174
2175                StringBundler query = new StringBundler(2);
2176
2177                query.append(_SQL_COUNT_ASSETLINK_WHERE);
2178
2179                query.append(_FINDER_COLUMN_E1_ENTRYID1_2);
2180
2181                String sql = query.toString();
2182
2183                Query q = session.createQuery(sql);
2184
2185                QueryPos qPos = QueryPos.getInstance(q);
2186
2187                qPos.add(entryId1);
2188
2189                count = (Long)q.uniqueResult();
2190            }
2191            catch (Exception e) {
2192                throw processException(e);
2193            }
2194            finally {
2195                if (count == null) {
2196                    count = Long.valueOf(0);
2197                }
2198
2199                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_E1, finderArgs,
2200                    count);
2201
2202                closeSession(session);
2203            }
2204        }
2205
2206        return count.intValue();
2207    }
2208
2209    public int countByE2(long entryId2) throws SystemException {
2210        Object[] finderArgs = new Object[] { new Long(entryId2) };
2211
2212        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_E2,
2213                finderArgs, this);
2214
2215        if (count == null) {
2216            Session session = null;
2217
2218            try {
2219                session = openSession();
2220
2221                StringBundler query = new StringBundler(2);
2222
2223                query.append(_SQL_COUNT_ASSETLINK_WHERE);
2224
2225                query.append(_FINDER_COLUMN_E2_ENTRYID2_2);
2226
2227                String sql = query.toString();
2228
2229                Query q = session.createQuery(sql);
2230
2231                QueryPos qPos = QueryPos.getInstance(q);
2232
2233                qPos.add(entryId2);
2234
2235                count = (Long)q.uniqueResult();
2236            }
2237            catch (Exception e) {
2238                throw processException(e);
2239            }
2240            finally {
2241                if (count == null) {
2242                    count = Long.valueOf(0);
2243                }
2244
2245                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_E2, finderArgs,
2246                    count);
2247
2248                closeSession(session);
2249            }
2250        }
2251
2252        return count.intValue();
2253    }
2254
2255    public int countByE_E(long entryId1, long entryId2)
2256        throws SystemException {
2257        Object[] finderArgs = new Object[] {
2258                new Long(entryId1), new Long(entryId2)
2259            };
2260
2261        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_E_E,
2262                finderArgs, this);
2263
2264        if (count == null) {
2265            Session session = null;
2266
2267            try {
2268                session = openSession();
2269
2270                StringBundler query = new StringBundler(3);
2271
2272                query.append(_SQL_COUNT_ASSETLINK_WHERE);
2273
2274                query.append(_FINDER_COLUMN_E_E_ENTRYID1_2);
2275
2276                query.append(_FINDER_COLUMN_E_E_ENTRYID2_2);
2277
2278                String sql = query.toString();
2279
2280                Query q = session.createQuery(sql);
2281
2282                QueryPos qPos = QueryPos.getInstance(q);
2283
2284                qPos.add(entryId1);
2285
2286                qPos.add(entryId2);
2287
2288                count = (Long)q.uniqueResult();
2289            }
2290            catch (Exception e) {
2291                throw processException(e);
2292            }
2293            finally {
2294                if (count == null) {
2295                    count = Long.valueOf(0);
2296                }
2297
2298                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_E_E, finderArgs,
2299                    count);
2300
2301                closeSession(session);
2302            }
2303        }
2304
2305        return count.intValue();
2306    }
2307
2308    public int countByE1_T(long entryId1, int type) throws SystemException {
2309        Object[] finderArgs = new Object[] { new Long(entryId1), new Integer(type) };
2310
2311        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_E1_T,
2312                finderArgs, this);
2313
2314        if (count == null) {
2315            Session session = null;
2316
2317            try {
2318                session = openSession();
2319
2320                StringBundler query = new StringBundler(3);
2321
2322                query.append(_SQL_COUNT_ASSETLINK_WHERE);
2323
2324                query.append(_FINDER_COLUMN_E1_T_ENTRYID1_2);
2325
2326                query.append(_FINDER_COLUMN_E1_T_TYPE_2);
2327
2328                String sql = query.toString();
2329
2330                Query q = session.createQuery(sql);
2331
2332                QueryPos qPos = QueryPos.getInstance(q);
2333
2334                qPos.add(entryId1);
2335
2336                qPos.add(type);
2337
2338                count = (Long)q.uniqueResult();
2339            }
2340            catch (Exception e) {
2341                throw processException(e);
2342            }
2343            finally {
2344                if (count == null) {
2345                    count = Long.valueOf(0);
2346                }
2347
2348                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_E1_T,
2349                    finderArgs, count);
2350
2351                closeSession(session);
2352            }
2353        }
2354
2355        return count.intValue();
2356    }
2357
2358    public int countByE2_T(long entryId2, int type) throws SystemException {
2359        Object[] finderArgs = new Object[] { new Long(entryId2), new Integer(type) };
2360
2361        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_E2_T,
2362                finderArgs, this);
2363
2364        if (count == null) {
2365            Session session = null;
2366
2367            try {
2368                session = openSession();
2369
2370                StringBundler query = new StringBundler(3);
2371
2372                query.append(_SQL_COUNT_ASSETLINK_WHERE);
2373
2374                query.append(_FINDER_COLUMN_E2_T_ENTRYID2_2);
2375
2376                query.append(_FINDER_COLUMN_E2_T_TYPE_2);
2377
2378                String sql = query.toString();
2379
2380                Query q = session.createQuery(sql);
2381
2382                QueryPos qPos = QueryPos.getInstance(q);
2383
2384                qPos.add(entryId2);
2385
2386                qPos.add(type);
2387
2388                count = (Long)q.uniqueResult();
2389            }
2390            catch (Exception e) {
2391                throw processException(e);
2392            }
2393            finally {
2394                if (count == null) {
2395                    count = Long.valueOf(0);
2396                }
2397
2398                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_E2_T,
2399                    finderArgs, count);
2400
2401                closeSession(session);
2402            }
2403        }
2404
2405        return count.intValue();
2406    }
2407
2408    public int countByE_E_T(long entryId1, long entryId2, int type)
2409        throws SystemException {
2410        Object[] finderArgs = new Object[] {
2411                new Long(entryId1), new Long(entryId2), new Integer(type)
2412            };
2413
2414        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_E_E_T,
2415                finderArgs, this);
2416
2417        if (count == null) {
2418            Session session = null;
2419
2420            try {
2421                session = openSession();
2422
2423                StringBundler query = new StringBundler(4);
2424
2425                query.append(_SQL_COUNT_ASSETLINK_WHERE);
2426
2427                query.append(_FINDER_COLUMN_E_E_T_ENTRYID1_2);
2428
2429                query.append(_FINDER_COLUMN_E_E_T_ENTRYID2_2);
2430
2431                query.append(_FINDER_COLUMN_E_E_T_TYPE_2);
2432
2433                String sql = query.toString();
2434
2435                Query q = session.createQuery(sql);
2436
2437                QueryPos qPos = QueryPos.getInstance(q);
2438
2439                qPos.add(entryId1);
2440
2441                qPos.add(entryId2);
2442
2443                qPos.add(type);
2444
2445                count = (Long)q.uniqueResult();
2446            }
2447            catch (Exception e) {
2448                throw processException(e);
2449            }
2450            finally {
2451                if (count == null) {
2452                    count = Long.valueOf(0);
2453                }
2454
2455                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_E_E_T,
2456                    finderArgs, count);
2457
2458                closeSession(session);
2459            }
2460        }
2461
2462        return count.intValue();
2463    }
2464
2465    public int countAll() throws SystemException {
2466        Object[] finderArgs = new Object[0];
2467
2468        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
2469                finderArgs, this);
2470
2471        if (count == null) {
2472            Session session = null;
2473
2474            try {
2475                session = openSession();
2476
2477                Query q = session.createQuery(_SQL_COUNT_ASSETLINK);
2478
2479                count = (Long)q.uniqueResult();
2480            }
2481            catch (Exception e) {
2482                throw processException(e);
2483            }
2484            finally {
2485                if (count == null) {
2486                    count = Long.valueOf(0);
2487                }
2488
2489                FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
2490                    count);
2491
2492                closeSession(session);
2493            }
2494        }
2495
2496        return count.intValue();
2497    }
2498
2499    public void afterPropertiesSet() {
2500        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
2501                    com.liferay.portal.util.PropsUtil.get(
2502                        "value.object.listener.com.liferay.portlet.asset.model.AssetLink")));
2503
2504        if (listenerClassNames.length > 0) {
2505            try {
2506                List<ModelListener<AssetLink>> listenersList = new ArrayList<ModelListener<AssetLink>>();
2507
2508                for (String listenerClassName : listenerClassNames) {
2509                    listenersList.add((ModelListener<AssetLink>)InstanceFactory.newInstance(
2510                            listenerClassName));
2511                }
2512
2513                listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
2514            }
2515            catch (Exception e) {
2516                _log.error(e);
2517            }
2518        }
2519    }
2520
2521    @BeanReference(type = AssetCategoryPersistence.class)
2522    protected AssetCategoryPersistence assetCategoryPersistence;
2523    @BeanReference(type = AssetCategoryPropertyPersistence.class)
2524    protected AssetCategoryPropertyPersistence assetCategoryPropertyPersistence;
2525    @BeanReference(type = AssetEntryPersistence.class)
2526    protected AssetEntryPersistence assetEntryPersistence;
2527    @BeanReference(type = AssetLinkPersistence.class)
2528    protected AssetLinkPersistence assetLinkPersistence;
2529    @BeanReference(type = AssetTagPersistence.class)
2530    protected AssetTagPersistence assetTagPersistence;
2531    @BeanReference(type = AssetTagPropertyPersistence.class)
2532    protected AssetTagPropertyPersistence assetTagPropertyPersistence;
2533    @BeanReference(type = AssetTagStatsPersistence.class)
2534    protected AssetTagStatsPersistence assetTagStatsPersistence;
2535    @BeanReference(type = AssetVocabularyPersistence.class)
2536    protected AssetVocabularyPersistence assetVocabularyPersistence;
2537    @BeanReference(type = ResourcePersistence.class)
2538    protected ResourcePersistence resourcePersistence;
2539    @BeanReference(type = UserPersistence.class)
2540    protected UserPersistence userPersistence;
2541    private static final String _SQL_SELECT_ASSETLINK = "SELECT assetLink FROM AssetLink assetLink";
2542    private static final String _SQL_SELECT_ASSETLINK_WHERE = "SELECT assetLink FROM AssetLink assetLink WHERE ";
2543    private static final String _SQL_COUNT_ASSETLINK = "SELECT COUNT(assetLink) FROM AssetLink assetLink";
2544    private static final String _SQL_COUNT_ASSETLINK_WHERE = "SELECT COUNT(assetLink) FROM AssetLink assetLink WHERE ";
2545    private static final String _FINDER_COLUMN_E1_ENTRYID1_2 = "assetLink.entryId1 = ?";
2546    private static final String _FINDER_COLUMN_E2_ENTRYID2_2 = "assetLink.entryId2 = ?";
2547    private static final String _FINDER_COLUMN_E_E_ENTRYID1_2 = "assetLink.entryId1 = ? AND ";
2548    private static final String _FINDER_COLUMN_E_E_ENTRYID2_2 = "assetLink.entryId2 = ?";
2549    private static final String _FINDER_COLUMN_E1_T_ENTRYID1_2 = "assetLink.entryId1 = ? AND ";
2550    private static final String _FINDER_COLUMN_E1_T_TYPE_2 = "assetLink.type = ?";
2551    private static final String _FINDER_COLUMN_E2_T_ENTRYID2_2 = "assetLink.entryId2 = ? AND ";
2552    private static final String _FINDER_COLUMN_E2_T_TYPE_2 = "assetLink.type = ?";
2553    private static final String _FINDER_COLUMN_E_E_T_ENTRYID1_2 = "assetLink.entryId1 = ? AND ";
2554    private static final String _FINDER_COLUMN_E_E_T_ENTRYID2_2 = "assetLink.entryId2 = ? AND ";
2555    private static final String _FINDER_COLUMN_E_E_T_TYPE_2 = "assetLink.type = ?";
2556    private static final String _ORDER_BY_ENTITY_ALIAS = "assetLink.";
2557    private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No AssetLink exists with the primary key ";
2558    private static final String _NO_SUCH_ENTITY_WITH_KEY = "No AssetLink exists with the key {";
2559    private static Log _log = LogFactoryUtil.getLog(AssetLinkPersistenceImpl.class);
2560}