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