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.kernel.util.Validator;
037    import com.liferay.portal.model.ModelListener;
038    import com.liferay.portal.service.persistence.BatchSessionUtil;
039    import com.liferay.portal.service.persistence.ResourcePersistence;
040    import com.liferay.portal.service.persistence.UserPersistence;
041    import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
042    
043    import com.liferay.portlet.asset.NoSuchTagPropertyException;
044    import com.liferay.portlet.asset.model.AssetTagProperty;
045    import com.liferay.portlet.asset.model.impl.AssetTagPropertyImpl;
046    import com.liferay.portlet.asset.model.impl.AssetTagPropertyModelImpl;
047    
048    import java.io.Serializable;
049    
050    import java.util.ArrayList;
051    import java.util.Collections;
052    import java.util.List;
053    
054    /**
055     * @author    Brian Wing Shun Chan
056     * @see       AssetTagPropertyPersistence
057     * @see       AssetTagPropertyUtil
058     * @generated
059     */
060    public class AssetTagPropertyPersistenceImpl extends BasePersistenceImpl<AssetTagProperty>
061            implements AssetTagPropertyPersistence {
062            public static final String FINDER_CLASS_NAME_ENTITY = AssetTagPropertyImpl.class.getName();
063            public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
064                    ".List";
065            public static final FinderPath FINDER_PATH_FIND_BY_COMPANYID = new FinderPath(AssetTagPropertyModelImpl.ENTITY_CACHE_ENABLED,
066                            AssetTagPropertyModelImpl.FINDER_CACHE_ENABLED,
067                            FINDER_CLASS_NAME_LIST, "findByCompanyId",
068                            new String[] {
069                                    Long.class.getName(),
070                                    
071                            "java.lang.Integer", "java.lang.Integer",
072                                    "com.liferay.portal.kernel.util.OrderByComparator"
073                            });
074            public static final FinderPath FINDER_PATH_COUNT_BY_COMPANYID = new FinderPath(AssetTagPropertyModelImpl.ENTITY_CACHE_ENABLED,
075                            AssetTagPropertyModelImpl.FINDER_CACHE_ENABLED,
076                            FINDER_CLASS_NAME_LIST, "countByCompanyId",
077                            new String[] { Long.class.getName() });
078            public static final FinderPath FINDER_PATH_FIND_BY_TAGID = new FinderPath(AssetTagPropertyModelImpl.ENTITY_CACHE_ENABLED,
079                            AssetTagPropertyModelImpl.FINDER_CACHE_ENABLED,
080                            FINDER_CLASS_NAME_LIST, "findByTagId",
081                            new String[] {
082                                    Long.class.getName(),
083                                    
084                            "java.lang.Integer", "java.lang.Integer",
085                                    "com.liferay.portal.kernel.util.OrderByComparator"
086                            });
087            public static final FinderPath FINDER_PATH_COUNT_BY_TAGID = new FinderPath(AssetTagPropertyModelImpl.ENTITY_CACHE_ENABLED,
088                            AssetTagPropertyModelImpl.FINDER_CACHE_ENABLED,
089                            FINDER_CLASS_NAME_LIST, "countByTagId",
090                            new String[] { Long.class.getName() });
091            public static final FinderPath FINDER_PATH_FIND_BY_C_K = new FinderPath(AssetTagPropertyModelImpl.ENTITY_CACHE_ENABLED,
092                            AssetTagPropertyModelImpl.FINDER_CACHE_ENABLED,
093                            FINDER_CLASS_NAME_LIST, "findByC_K",
094                            new String[] {
095                                    Long.class.getName(), String.class.getName(),
096                                    
097                            "java.lang.Integer", "java.lang.Integer",
098                                    "com.liferay.portal.kernel.util.OrderByComparator"
099                            });
100            public static final FinderPath FINDER_PATH_COUNT_BY_C_K = new FinderPath(AssetTagPropertyModelImpl.ENTITY_CACHE_ENABLED,
101                            AssetTagPropertyModelImpl.FINDER_CACHE_ENABLED,
102                            FINDER_CLASS_NAME_LIST, "countByC_K",
103                            new String[] { Long.class.getName(), String.class.getName() });
104            public static final FinderPath FINDER_PATH_FETCH_BY_T_K = new FinderPath(AssetTagPropertyModelImpl.ENTITY_CACHE_ENABLED,
105                            AssetTagPropertyModelImpl.FINDER_CACHE_ENABLED,
106                            FINDER_CLASS_NAME_ENTITY, "fetchByT_K",
107                            new String[] { Long.class.getName(), String.class.getName() });
108            public static final FinderPath FINDER_PATH_COUNT_BY_T_K = new FinderPath(AssetTagPropertyModelImpl.ENTITY_CACHE_ENABLED,
109                            AssetTagPropertyModelImpl.FINDER_CACHE_ENABLED,
110                            FINDER_CLASS_NAME_LIST, "countByT_K",
111                            new String[] { Long.class.getName(), String.class.getName() });
112            public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(AssetTagPropertyModelImpl.ENTITY_CACHE_ENABLED,
113                            AssetTagPropertyModelImpl.FINDER_CACHE_ENABLED,
114                            FINDER_CLASS_NAME_LIST, "findAll", new String[0]);
115            public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(AssetTagPropertyModelImpl.ENTITY_CACHE_ENABLED,
116                            AssetTagPropertyModelImpl.FINDER_CACHE_ENABLED,
117                            FINDER_CLASS_NAME_LIST, "countAll", new String[0]);
118    
119            public void cacheResult(AssetTagProperty assetTagProperty) {
120                    EntityCacheUtil.putResult(AssetTagPropertyModelImpl.ENTITY_CACHE_ENABLED,
121                            AssetTagPropertyImpl.class, assetTagProperty.getPrimaryKey(),
122                            assetTagProperty);
123    
124                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_T_K,
125                            new Object[] {
126                                    new Long(assetTagProperty.getTagId()),
127                                    
128                            assetTagProperty.getKey()
129                            }, assetTagProperty);
130            }
131    
132            public void cacheResult(List<AssetTagProperty> assetTagProperties) {
133                    for (AssetTagProperty assetTagProperty : assetTagProperties) {
134                            if (EntityCacheUtil.getResult(
135                                                    AssetTagPropertyModelImpl.ENTITY_CACHE_ENABLED,
136                                                    AssetTagPropertyImpl.class,
137                                                    assetTagProperty.getPrimaryKey(), this) == null) {
138                                    cacheResult(assetTagProperty);
139                            }
140                    }
141            }
142    
143            public void clearCache() {
144                    CacheRegistryUtil.clear(AssetTagPropertyImpl.class.getName());
145                    EntityCacheUtil.clearCache(AssetTagPropertyImpl.class.getName());
146                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
147                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
148            }
149    
150            public void clearCache(AssetTagProperty assetTagProperty) {
151                    EntityCacheUtil.removeResult(AssetTagPropertyModelImpl.ENTITY_CACHE_ENABLED,
152                            AssetTagPropertyImpl.class, assetTagProperty.getPrimaryKey());
153    
154                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_T_K,
155                            new Object[] {
156                                    new Long(assetTagProperty.getTagId()),
157                                    
158                            assetTagProperty.getKey()
159                            });
160            }
161    
162            public AssetTagProperty create(long tagPropertyId) {
163                    AssetTagProperty assetTagProperty = new AssetTagPropertyImpl();
164    
165                    assetTagProperty.setNew(true);
166                    assetTagProperty.setPrimaryKey(tagPropertyId);
167    
168                    return assetTagProperty;
169            }
170    
171            public AssetTagProperty remove(Serializable primaryKey)
172                    throws NoSuchModelException, SystemException {
173                    return remove(((Long)primaryKey).longValue());
174            }
175    
176            public AssetTagProperty remove(long tagPropertyId)
177                    throws NoSuchTagPropertyException, SystemException {
178                    Session session = null;
179    
180                    try {
181                            session = openSession();
182    
183                            AssetTagProperty assetTagProperty = (AssetTagProperty)session.get(AssetTagPropertyImpl.class,
184                                            new Long(tagPropertyId));
185    
186                            if (assetTagProperty == null) {
187                                    if (_log.isWarnEnabled()) {
188                                            _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + tagPropertyId);
189                                    }
190    
191                                    throw new NoSuchTagPropertyException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
192                                            tagPropertyId);
193                            }
194    
195                            return remove(assetTagProperty);
196                    }
197                    catch (NoSuchTagPropertyException nsee) {
198                            throw nsee;
199                    }
200                    catch (Exception e) {
201                            throw processException(e);
202                    }
203                    finally {
204                            closeSession(session);
205                    }
206            }
207    
208            protected AssetTagProperty removeImpl(AssetTagProperty assetTagProperty)
209                    throws SystemException {
210                    assetTagProperty = toUnwrappedModel(assetTagProperty);
211    
212                    Session session = null;
213    
214                    try {
215                            session = openSession();
216    
217                            if (assetTagProperty.isCachedModel() ||
218                                            BatchSessionUtil.isEnabled()) {
219                                    Object staleObject = session.get(AssetTagPropertyImpl.class,
220                                                    assetTagProperty.getPrimaryKeyObj());
221    
222                                    if (staleObject != null) {
223                                            session.evict(staleObject);
224                                    }
225                            }
226    
227                            session.delete(assetTagProperty);
228    
229                            session.flush();
230                    }
231                    catch (Exception e) {
232                            throw processException(e);
233                    }
234                    finally {
235                            closeSession(session);
236                    }
237    
238                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
239    
240                    AssetTagPropertyModelImpl assetTagPropertyModelImpl = (AssetTagPropertyModelImpl)assetTagProperty;
241    
242                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_T_K,
243                            new Object[] {
244                                    new Long(assetTagPropertyModelImpl.getOriginalTagId()),
245                                    
246                            assetTagPropertyModelImpl.getOriginalKey()
247                            });
248    
249                    EntityCacheUtil.removeResult(AssetTagPropertyModelImpl.ENTITY_CACHE_ENABLED,
250                            AssetTagPropertyImpl.class, assetTagProperty.getPrimaryKey());
251    
252                    return assetTagProperty;
253            }
254    
255            public AssetTagProperty updateImpl(
256                    com.liferay.portlet.asset.model.AssetTagProperty assetTagProperty,
257                    boolean merge) throws SystemException {
258                    assetTagProperty = toUnwrappedModel(assetTagProperty);
259    
260                    boolean isNew = assetTagProperty.isNew();
261    
262                    AssetTagPropertyModelImpl assetTagPropertyModelImpl = (AssetTagPropertyModelImpl)assetTagProperty;
263    
264                    Session session = null;
265    
266                    try {
267                            session = openSession();
268    
269                            BatchSessionUtil.update(session, assetTagProperty, merge);
270    
271                            assetTagProperty.setNew(false);
272                    }
273                    catch (Exception e) {
274                            throw processException(e);
275                    }
276                    finally {
277                            closeSession(session);
278                    }
279    
280                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
281    
282                    EntityCacheUtil.putResult(AssetTagPropertyModelImpl.ENTITY_CACHE_ENABLED,
283                            AssetTagPropertyImpl.class, assetTagProperty.getPrimaryKey(),
284                            assetTagProperty);
285    
286                    if (!isNew &&
287                                    ((assetTagProperty.getTagId() != assetTagPropertyModelImpl.getOriginalTagId()) ||
288                                    !Validator.equals(assetTagProperty.getKey(),
289                                            assetTagPropertyModelImpl.getOriginalKey()))) {
290                            FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_T_K,
291                                    new Object[] {
292                                            new Long(assetTagPropertyModelImpl.getOriginalTagId()),
293                                            
294                                    assetTagPropertyModelImpl.getOriginalKey()
295                                    });
296                    }
297    
298                    if (isNew ||
299                                    ((assetTagProperty.getTagId() != assetTagPropertyModelImpl.getOriginalTagId()) ||
300                                    !Validator.equals(assetTagProperty.getKey(),
301                                            assetTagPropertyModelImpl.getOriginalKey()))) {
302                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_T_K,
303                                    new Object[] {
304                                            new Long(assetTagProperty.getTagId()),
305                                            
306                                    assetTagProperty.getKey()
307                                    }, assetTagProperty);
308                    }
309    
310                    return assetTagProperty;
311            }
312    
313            protected AssetTagProperty toUnwrappedModel(
314                    AssetTagProperty assetTagProperty) {
315                    if (assetTagProperty instanceof AssetTagPropertyImpl) {
316                            return assetTagProperty;
317                    }
318    
319                    AssetTagPropertyImpl assetTagPropertyImpl = new AssetTagPropertyImpl();
320    
321                    assetTagPropertyImpl.setNew(assetTagProperty.isNew());
322                    assetTagPropertyImpl.setPrimaryKey(assetTagProperty.getPrimaryKey());
323    
324                    assetTagPropertyImpl.setTagPropertyId(assetTagProperty.getTagPropertyId());
325                    assetTagPropertyImpl.setCompanyId(assetTagProperty.getCompanyId());
326                    assetTagPropertyImpl.setUserId(assetTagProperty.getUserId());
327                    assetTagPropertyImpl.setUserName(assetTagProperty.getUserName());
328                    assetTagPropertyImpl.setCreateDate(assetTagProperty.getCreateDate());
329                    assetTagPropertyImpl.setModifiedDate(assetTagProperty.getModifiedDate());
330                    assetTagPropertyImpl.setTagId(assetTagProperty.getTagId());
331                    assetTagPropertyImpl.setKey(assetTagProperty.getKey());
332                    assetTagPropertyImpl.setValue(assetTagProperty.getValue());
333    
334                    return assetTagPropertyImpl;
335            }
336    
337            public AssetTagProperty findByPrimaryKey(Serializable primaryKey)
338                    throws NoSuchModelException, SystemException {
339                    return findByPrimaryKey(((Long)primaryKey).longValue());
340            }
341    
342            public AssetTagProperty findByPrimaryKey(long tagPropertyId)
343                    throws NoSuchTagPropertyException, SystemException {
344                    AssetTagProperty assetTagProperty = fetchByPrimaryKey(tagPropertyId);
345    
346                    if (assetTagProperty == null) {
347                            if (_log.isWarnEnabled()) {
348                                    _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + tagPropertyId);
349                            }
350    
351                            throw new NoSuchTagPropertyException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
352                                    tagPropertyId);
353                    }
354    
355                    return assetTagProperty;
356            }
357    
358            public AssetTagProperty fetchByPrimaryKey(Serializable primaryKey)
359                    throws SystemException {
360                    return fetchByPrimaryKey(((Long)primaryKey).longValue());
361            }
362    
363            public AssetTagProperty fetchByPrimaryKey(long tagPropertyId)
364                    throws SystemException {
365                    AssetTagProperty assetTagProperty = (AssetTagProperty)EntityCacheUtil.getResult(AssetTagPropertyModelImpl.ENTITY_CACHE_ENABLED,
366                                    AssetTagPropertyImpl.class, tagPropertyId, this);
367    
368                    if (assetTagProperty == null) {
369                            Session session = null;
370    
371                            try {
372                                    session = openSession();
373    
374                                    assetTagProperty = (AssetTagProperty)session.get(AssetTagPropertyImpl.class,
375                                                    new Long(tagPropertyId));
376                            }
377                            catch (Exception e) {
378                                    throw processException(e);
379                            }
380                            finally {
381                                    if (assetTagProperty != null) {
382                                            cacheResult(assetTagProperty);
383                                    }
384    
385                                    closeSession(session);
386                            }
387                    }
388    
389                    return assetTagProperty;
390            }
391    
392            public List<AssetTagProperty> findByCompanyId(long companyId)
393                    throws SystemException {
394                    return findByCompanyId(companyId, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
395                            null);
396            }
397    
398            public List<AssetTagProperty> findByCompanyId(long companyId, int start,
399                    int end) throws SystemException {
400                    return findByCompanyId(companyId, start, end, null);
401            }
402    
403            public List<AssetTagProperty> findByCompanyId(long companyId, int start,
404                    int end, OrderByComparator orderByComparator) throws SystemException {
405                    Object[] finderArgs = new Object[] {
406                                    companyId,
407                                    
408                                    String.valueOf(start), String.valueOf(end),
409                                    String.valueOf(orderByComparator)
410                            };
411    
412                    List<AssetTagProperty> list = (List<AssetTagProperty>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_COMPANYID,
413                                    finderArgs, this);
414    
415                    if (list == null) {
416                            Session session = null;
417    
418                            try {
419                                    session = openSession();
420    
421                                    StringBundler query = null;
422    
423                                    if (orderByComparator != null) {
424                                            query = new StringBundler(3 +
425                                                            (orderByComparator.getOrderByFields().length * 3));
426                                    }
427                                    else {
428                                            query = new StringBundler(3);
429                                    }
430    
431                                    query.append(_SQL_SELECT_ASSETTAGPROPERTY_WHERE);
432    
433                                    query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
434    
435                                    if (orderByComparator != null) {
436                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
437                                                    orderByComparator);
438                                    }
439    
440                                    else {
441                                            query.append(AssetTagPropertyModelImpl.ORDER_BY_JPQL);
442                                    }
443    
444                                    String sql = query.toString();
445    
446                                    Query q = session.createQuery(sql);
447    
448                                    QueryPos qPos = QueryPos.getInstance(q);
449    
450                                    qPos.add(companyId);
451    
452                                    list = (List<AssetTagProperty>)QueryUtil.list(q, getDialect(),
453                                                    start, end);
454                            }
455                            catch (Exception e) {
456                                    throw processException(e);
457                            }
458                            finally {
459                                    if (list == null) {
460                                            list = new ArrayList<AssetTagProperty>();
461                                    }
462    
463                                    cacheResult(list);
464    
465                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_COMPANYID,
466                                            finderArgs, list);
467    
468                                    closeSession(session);
469                            }
470                    }
471    
472                    return list;
473            }
474    
475            public AssetTagProperty findByCompanyId_First(long companyId,
476                    OrderByComparator orderByComparator)
477                    throws NoSuchTagPropertyException, SystemException {
478                    List<AssetTagProperty> list = findByCompanyId(companyId, 0, 1,
479                                    orderByComparator);
480    
481                    if (list.isEmpty()) {
482                            StringBundler msg = new StringBundler(4);
483    
484                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
485    
486                            msg.append("companyId=");
487                            msg.append(companyId);
488    
489                            msg.append(StringPool.CLOSE_CURLY_BRACE);
490    
491                            throw new NoSuchTagPropertyException(msg.toString());
492                    }
493                    else {
494                            return list.get(0);
495                    }
496            }
497    
498            public AssetTagProperty findByCompanyId_Last(long companyId,
499                    OrderByComparator orderByComparator)
500                    throws NoSuchTagPropertyException, SystemException {
501                    int count = countByCompanyId(companyId);
502    
503                    List<AssetTagProperty> list = findByCompanyId(companyId, count - 1,
504                                    count, orderByComparator);
505    
506                    if (list.isEmpty()) {
507                            StringBundler msg = new StringBundler(4);
508    
509                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
510    
511                            msg.append("companyId=");
512                            msg.append(companyId);
513    
514                            msg.append(StringPool.CLOSE_CURLY_BRACE);
515    
516                            throw new NoSuchTagPropertyException(msg.toString());
517                    }
518                    else {
519                            return list.get(0);
520                    }
521            }
522    
523            public AssetTagProperty[] findByCompanyId_PrevAndNext(long tagPropertyId,
524                    long companyId, OrderByComparator orderByComparator)
525                    throws NoSuchTagPropertyException, SystemException {
526                    AssetTagProperty assetTagProperty = findByPrimaryKey(tagPropertyId);
527    
528                    Session session = null;
529    
530                    try {
531                            session = openSession();
532    
533                            AssetTagProperty[] array = new AssetTagPropertyImpl[3];
534    
535                            array[0] = getByCompanyId_PrevAndNext(session, assetTagProperty,
536                                            companyId, orderByComparator, true);
537    
538                            array[1] = assetTagProperty;
539    
540                            array[2] = getByCompanyId_PrevAndNext(session, assetTagProperty,
541                                            companyId, orderByComparator, false);
542    
543                            return array;
544                    }
545                    catch (Exception e) {
546                            throw processException(e);
547                    }
548                    finally {
549                            closeSession(session);
550                    }
551            }
552    
553            protected AssetTagProperty getByCompanyId_PrevAndNext(Session session,
554                    AssetTagProperty assetTagProperty, long companyId,
555                    OrderByComparator orderByComparator, boolean previous) {
556                    StringBundler query = null;
557    
558                    if (orderByComparator != null) {
559                            query = new StringBundler(6 +
560                                            (orderByComparator.getOrderByFields().length * 6));
561                    }
562                    else {
563                            query = new StringBundler(3);
564                    }
565    
566                    query.append(_SQL_SELECT_ASSETTAGPROPERTY_WHERE);
567    
568                    query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
569    
570                    if (orderByComparator != null) {
571                            String[] orderByFields = orderByComparator.getOrderByFields();
572    
573                            if (orderByFields.length > 0) {
574                                    query.append(WHERE_AND);
575                            }
576    
577                            for (int i = 0; i < orderByFields.length; i++) {
578                                    query.append(_ORDER_BY_ENTITY_ALIAS);
579                                    query.append(orderByFields[i]);
580    
581                                    if ((i + 1) < orderByFields.length) {
582                                            if (orderByComparator.isAscending() ^ previous) {
583                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
584                                            }
585                                            else {
586                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
587                                            }
588                                    }
589                                    else {
590                                            if (orderByComparator.isAscending() ^ previous) {
591                                                    query.append(WHERE_GREATER_THAN);
592                                            }
593                                            else {
594                                                    query.append(WHERE_LESSER_THAN);
595                                            }
596                                    }
597                            }
598    
599                            query.append(ORDER_BY_CLAUSE);
600    
601                            for (int i = 0; i < orderByFields.length; i++) {
602                                    query.append(_ORDER_BY_ENTITY_ALIAS);
603                                    query.append(orderByFields[i]);
604    
605                                    if ((i + 1) < orderByFields.length) {
606                                            if (orderByComparator.isAscending() ^ previous) {
607                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
608                                            }
609                                            else {
610                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
611                                            }
612                                    }
613                                    else {
614                                            if (orderByComparator.isAscending() ^ previous) {
615                                                    query.append(ORDER_BY_ASC);
616                                            }
617                                            else {
618                                                    query.append(ORDER_BY_DESC);
619                                            }
620                                    }
621                            }
622                    }
623    
624                    else {
625                            query.append(AssetTagPropertyModelImpl.ORDER_BY_JPQL);
626                    }
627    
628                    String sql = query.toString();
629    
630                    Query q = session.createQuery(sql);
631    
632                    q.setFirstResult(0);
633                    q.setMaxResults(2);
634    
635                    QueryPos qPos = QueryPos.getInstance(q);
636    
637                    qPos.add(companyId);
638    
639                    if (orderByComparator != null) {
640                            Object[] values = orderByComparator.getOrderByValues(assetTagProperty);
641    
642                            for (Object value : values) {
643                                    qPos.add(value);
644                            }
645                    }
646    
647                    List<AssetTagProperty> list = q.list();
648    
649                    if (list.size() == 2) {
650                            return list.get(1);
651                    }
652                    else {
653                            return null;
654                    }
655            }
656    
657            public List<AssetTagProperty> findByTagId(long tagId)
658                    throws SystemException {
659                    return findByTagId(tagId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
660            }
661    
662            public List<AssetTagProperty> findByTagId(long tagId, int start, int end)
663                    throws SystemException {
664                    return findByTagId(tagId, start, end, null);
665            }
666    
667            public List<AssetTagProperty> findByTagId(long tagId, int start, int end,
668                    OrderByComparator orderByComparator) throws SystemException {
669                    Object[] finderArgs = new Object[] {
670                                    tagId,
671                                    
672                                    String.valueOf(start), String.valueOf(end),
673                                    String.valueOf(orderByComparator)
674                            };
675    
676                    List<AssetTagProperty> list = (List<AssetTagProperty>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_TAGID,
677                                    finderArgs, this);
678    
679                    if (list == null) {
680                            Session session = null;
681    
682                            try {
683                                    session = openSession();
684    
685                                    StringBundler query = null;
686    
687                                    if (orderByComparator != null) {
688                                            query = new StringBundler(3 +
689                                                            (orderByComparator.getOrderByFields().length * 3));
690                                    }
691                                    else {
692                                            query = new StringBundler(3);
693                                    }
694    
695                                    query.append(_SQL_SELECT_ASSETTAGPROPERTY_WHERE);
696    
697                                    query.append(_FINDER_COLUMN_TAGID_TAGID_2);
698    
699                                    if (orderByComparator != null) {
700                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
701                                                    orderByComparator);
702                                    }
703    
704                                    else {
705                                            query.append(AssetTagPropertyModelImpl.ORDER_BY_JPQL);
706                                    }
707    
708                                    String sql = query.toString();
709    
710                                    Query q = session.createQuery(sql);
711    
712                                    QueryPos qPos = QueryPos.getInstance(q);
713    
714                                    qPos.add(tagId);
715    
716                                    list = (List<AssetTagProperty>)QueryUtil.list(q, getDialect(),
717                                                    start, end);
718                            }
719                            catch (Exception e) {
720                                    throw processException(e);
721                            }
722                            finally {
723                                    if (list == null) {
724                                            list = new ArrayList<AssetTagProperty>();
725                                    }
726    
727                                    cacheResult(list);
728    
729                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_TAGID,
730                                            finderArgs, list);
731    
732                                    closeSession(session);
733                            }
734                    }
735    
736                    return list;
737            }
738    
739            public AssetTagProperty findByTagId_First(long tagId,
740                    OrderByComparator orderByComparator)
741                    throws NoSuchTagPropertyException, SystemException {
742                    List<AssetTagProperty> list = findByTagId(tagId, 0, 1, orderByComparator);
743    
744                    if (list.isEmpty()) {
745                            StringBundler msg = new StringBundler(4);
746    
747                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
748    
749                            msg.append("tagId=");
750                            msg.append(tagId);
751    
752                            msg.append(StringPool.CLOSE_CURLY_BRACE);
753    
754                            throw new NoSuchTagPropertyException(msg.toString());
755                    }
756                    else {
757                            return list.get(0);
758                    }
759            }
760    
761            public AssetTagProperty findByTagId_Last(long tagId,
762                    OrderByComparator orderByComparator)
763                    throws NoSuchTagPropertyException, SystemException {
764                    int count = countByTagId(tagId);
765    
766                    List<AssetTagProperty> list = findByTagId(tagId, count - 1, count,
767                                    orderByComparator);
768    
769                    if (list.isEmpty()) {
770                            StringBundler msg = new StringBundler(4);
771    
772                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
773    
774                            msg.append("tagId=");
775                            msg.append(tagId);
776    
777                            msg.append(StringPool.CLOSE_CURLY_BRACE);
778    
779                            throw new NoSuchTagPropertyException(msg.toString());
780                    }
781                    else {
782                            return list.get(0);
783                    }
784            }
785    
786            public AssetTagProperty[] findByTagId_PrevAndNext(long tagPropertyId,
787                    long tagId, OrderByComparator orderByComparator)
788                    throws NoSuchTagPropertyException, SystemException {
789                    AssetTagProperty assetTagProperty = findByPrimaryKey(tagPropertyId);
790    
791                    Session session = null;
792    
793                    try {
794                            session = openSession();
795    
796                            AssetTagProperty[] array = new AssetTagPropertyImpl[3];
797    
798                            array[0] = getByTagId_PrevAndNext(session, assetTagProperty, tagId,
799                                            orderByComparator, true);
800    
801                            array[1] = assetTagProperty;
802    
803                            array[2] = getByTagId_PrevAndNext(session, assetTagProperty, tagId,
804                                            orderByComparator, false);
805    
806                            return array;
807                    }
808                    catch (Exception e) {
809                            throw processException(e);
810                    }
811                    finally {
812                            closeSession(session);
813                    }
814            }
815    
816            protected AssetTagProperty getByTagId_PrevAndNext(Session session,
817                    AssetTagProperty assetTagProperty, long tagId,
818                    OrderByComparator orderByComparator, boolean previous) {
819                    StringBundler query = null;
820    
821                    if (orderByComparator != null) {
822                            query = new StringBundler(6 +
823                                            (orderByComparator.getOrderByFields().length * 6));
824                    }
825                    else {
826                            query = new StringBundler(3);
827                    }
828    
829                    query.append(_SQL_SELECT_ASSETTAGPROPERTY_WHERE);
830    
831                    query.append(_FINDER_COLUMN_TAGID_TAGID_2);
832    
833                    if (orderByComparator != null) {
834                            String[] orderByFields = orderByComparator.getOrderByFields();
835    
836                            if (orderByFields.length > 0) {
837                                    query.append(WHERE_AND);
838                            }
839    
840                            for (int i = 0; i < orderByFields.length; i++) {
841                                    query.append(_ORDER_BY_ENTITY_ALIAS);
842                                    query.append(orderByFields[i]);
843    
844                                    if ((i + 1) < orderByFields.length) {
845                                            if (orderByComparator.isAscending() ^ previous) {
846                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
847                                            }
848                                            else {
849                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
850                                            }
851                                    }
852                                    else {
853                                            if (orderByComparator.isAscending() ^ previous) {
854                                                    query.append(WHERE_GREATER_THAN);
855                                            }
856                                            else {
857                                                    query.append(WHERE_LESSER_THAN);
858                                            }
859                                    }
860                            }
861    
862                            query.append(ORDER_BY_CLAUSE);
863    
864                            for (int i = 0; i < orderByFields.length; i++) {
865                                    query.append(_ORDER_BY_ENTITY_ALIAS);
866                                    query.append(orderByFields[i]);
867    
868                                    if ((i + 1) < orderByFields.length) {
869                                            if (orderByComparator.isAscending() ^ previous) {
870                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
871                                            }
872                                            else {
873                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
874                                            }
875                                    }
876                                    else {
877                                            if (orderByComparator.isAscending() ^ previous) {
878                                                    query.append(ORDER_BY_ASC);
879                                            }
880                                            else {
881                                                    query.append(ORDER_BY_DESC);
882                                            }
883                                    }
884                            }
885                    }
886    
887                    else {
888                            query.append(AssetTagPropertyModelImpl.ORDER_BY_JPQL);
889                    }
890    
891                    String sql = query.toString();
892    
893                    Query q = session.createQuery(sql);
894    
895                    q.setFirstResult(0);
896                    q.setMaxResults(2);
897    
898                    QueryPos qPos = QueryPos.getInstance(q);
899    
900                    qPos.add(tagId);
901    
902                    if (orderByComparator != null) {
903                            Object[] values = orderByComparator.getOrderByValues(assetTagProperty);
904    
905                            for (Object value : values) {
906                                    qPos.add(value);
907                            }
908                    }
909    
910                    List<AssetTagProperty> list = q.list();
911    
912                    if (list.size() == 2) {
913                            return list.get(1);
914                    }
915                    else {
916                            return null;
917                    }
918            }
919    
920            public List<AssetTagProperty> findByC_K(long companyId, String key)
921                    throws SystemException {
922                    return findByC_K(companyId, key, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
923                            null);
924            }
925    
926            public List<AssetTagProperty> findByC_K(long companyId, String key,
927                    int start, int end) throws SystemException {
928                    return findByC_K(companyId, key, start, end, null);
929            }
930    
931            public List<AssetTagProperty> findByC_K(long companyId, String key,
932                    int start, int end, OrderByComparator orderByComparator)
933                    throws SystemException {
934                    Object[] finderArgs = new Object[] {
935                                    companyId, key,
936                                    
937                                    String.valueOf(start), String.valueOf(end),
938                                    String.valueOf(orderByComparator)
939                            };
940    
941                    List<AssetTagProperty> list = (List<AssetTagProperty>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_C_K,
942                                    finderArgs, this);
943    
944                    if (list == null) {
945                            Session session = null;
946    
947                            try {
948                                    session = openSession();
949    
950                                    StringBundler query = null;
951    
952                                    if (orderByComparator != null) {
953                                            query = new StringBundler(4 +
954                                                            (orderByComparator.getOrderByFields().length * 3));
955                                    }
956                                    else {
957                                            query = new StringBundler(4);
958                                    }
959    
960                                    query.append(_SQL_SELECT_ASSETTAGPROPERTY_WHERE);
961    
962                                    query.append(_FINDER_COLUMN_C_K_COMPANYID_2);
963    
964                                    if (key == null) {
965                                            query.append(_FINDER_COLUMN_C_K_KEY_1);
966                                    }
967                                    else {
968                                            if (key.equals(StringPool.BLANK)) {
969                                                    query.append(_FINDER_COLUMN_C_K_KEY_3);
970                                            }
971                                            else {
972                                                    query.append(_FINDER_COLUMN_C_K_KEY_2);
973                                            }
974                                    }
975    
976                                    if (orderByComparator != null) {
977                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
978                                                    orderByComparator);
979                                    }
980    
981                                    else {
982                                            query.append(AssetTagPropertyModelImpl.ORDER_BY_JPQL);
983                                    }
984    
985                                    String sql = query.toString();
986    
987                                    Query q = session.createQuery(sql);
988    
989                                    QueryPos qPos = QueryPos.getInstance(q);
990    
991                                    qPos.add(companyId);
992    
993                                    if (key != null) {
994                                            qPos.add(key);
995                                    }
996    
997                                    list = (List<AssetTagProperty>)QueryUtil.list(q, getDialect(),
998                                                    start, end);
999                            }
1000                            catch (Exception e) {
1001                                    throw processException(e);
1002                            }
1003                            finally {
1004                                    if (list == null) {
1005                                            list = new ArrayList<AssetTagProperty>();
1006                                    }
1007    
1008                                    cacheResult(list);
1009    
1010                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_C_K, finderArgs,
1011                                            list);
1012    
1013                                    closeSession(session);
1014                            }
1015                    }
1016    
1017                    return list;
1018            }
1019    
1020            public AssetTagProperty findByC_K_First(long companyId, String key,
1021                    OrderByComparator orderByComparator)
1022                    throws NoSuchTagPropertyException, SystemException {
1023                    List<AssetTagProperty> list = findByC_K(companyId, key, 0, 1,
1024                                    orderByComparator);
1025    
1026                    if (list.isEmpty()) {
1027                            StringBundler msg = new StringBundler(6);
1028    
1029                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1030    
1031                            msg.append("companyId=");
1032                            msg.append(companyId);
1033    
1034                            msg.append(", key=");
1035                            msg.append(key);
1036    
1037                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1038    
1039                            throw new NoSuchTagPropertyException(msg.toString());
1040                    }
1041                    else {
1042                            return list.get(0);
1043                    }
1044            }
1045    
1046            public AssetTagProperty findByC_K_Last(long companyId, String key,
1047                    OrderByComparator orderByComparator)
1048                    throws NoSuchTagPropertyException, SystemException {
1049                    int count = countByC_K(companyId, key);
1050    
1051                    List<AssetTagProperty> list = findByC_K(companyId, key, count - 1,
1052                                    count, orderByComparator);
1053    
1054                    if (list.isEmpty()) {
1055                            StringBundler msg = new StringBundler(6);
1056    
1057                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1058    
1059                            msg.append("companyId=");
1060                            msg.append(companyId);
1061    
1062                            msg.append(", key=");
1063                            msg.append(key);
1064    
1065                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1066    
1067                            throw new NoSuchTagPropertyException(msg.toString());
1068                    }
1069                    else {
1070                            return list.get(0);
1071                    }
1072            }
1073    
1074            public AssetTagProperty[] findByC_K_PrevAndNext(long tagPropertyId,
1075                    long companyId, String key, OrderByComparator orderByComparator)
1076                    throws NoSuchTagPropertyException, SystemException {
1077                    AssetTagProperty assetTagProperty = findByPrimaryKey(tagPropertyId);
1078    
1079                    Session session = null;
1080    
1081                    try {
1082                            session = openSession();
1083    
1084                            AssetTagProperty[] array = new AssetTagPropertyImpl[3];
1085    
1086                            array[0] = getByC_K_PrevAndNext(session, assetTagProperty,
1087                                            companyId, key, orderByComparator, true);
1088    
1089                            array[1] = assetTagProperty;
1090    
1091                            array[2] = getByC_K_PrevAndNext(session, assetTagProperty,
1092                                            companyId, key, orderByComparator, false);
1093    
1094                            return array;
1095                    }
1096                    catch (Exception e) {
1097                            throw processException(e);
1098                    }
1099                    finally {
1100                            closeSession(session);
1101                    }
1102            }
1103    
1104            protected AssetTagProperty getByC_K_PrevAndNext(Session session,
1105                    AssetTagProperty assetTagProperty, long companyId, String key,
1106                    OrderByComparator orderByComparator, boolean previous) {
1107                    StringBundler query = null;
1108    
1109                    if (orderByComparator != null) {
1110                            query = new StringBundler(6 +
1111                                            (orderByComparator.getOrderByFields().length * 6));
1112                    }
1113                    else {
1114                            query = new StringBundler(3);
1115                    }
1116    
1117                    query.append(_SQL_SELECT_ASSETTAGPROPERTY_WHERE);
1118    
1119                    query.append(_FINDER_COLUMN_C_K_COMPANYID_2);
1120    
1121                    if (key == null) {
1122                            query.append(_FINDER_COLUMN_C_K_KEY_1);
1123                    }
1124                    else {
1125                            if (key.equals(StringPool.BLANK)) {
1126                                    query.append(_FINDER_COLUMN_C_K_KEY_3);
1127                            }
1128                            else {
1129                                    query.append(_FINDER_COLUMN_C_K_KEY_2);
1130                            }
1131                    }
1132    
1133                    if (orderByComparator != null) {
1134                            String[] orderByFields = orderByComparator.getOrderByFields();
1135    
1136                            if (orderByFields.length > 0) {
1137                                    query.append(WHERE_AND);
1138                            }
1139    
1140                            for (int i = 0; i < orderByFields.length; i++) {
1141                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1142                                    query.append(orderByFields[i]);
1143    
1144                                    if ((i + 1) < orderByFields.length) {
1145                                            if (orderByComparator.isAscending() ^ previous) {
1146                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
1147                                            }
1148                                            else {
1149                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
1150                                            }
1151                                    }
1152                                    else {
1153                                            if (orderByComparator.isAscending() ^ previous) {
1154                                                    query.append(WHERE_GREATER_THAN);
1155                                            }
1156                                            else {
1157                                                    query.append(WHERE_LESSER_THAN);
1158                                            }
1159                                    }
1160                            }
1161    
1162                            query.append(ORDER_BY_CLAUSE);
1163    
1164                            for (int i = 0; i < orderByFields.length; i++) {
1165                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1166                                    query.append(orderByFields[i]);
1167    
1168                                    if ((i + 1) < orderByFields.length) {
1169                                            if (orderByComparator.isAscending() ^ previous) {
1170                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
1171                                            }
1172                                            else {
1173                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
1174                                            }
1175                                    }
1176                                    else {
1177                                            if (orderByComparator.isAscending() ^ previous) {
1178                                                    query.append(ORDER_BY_ASC);
1179                                            }
1180                                            else {
1181                                                    query.append(ORDER_BY_DESC);
1182                                            }
1183                                    }
1184                            }
1185                    }
1186    
1187                    else {
1188                            query.append(AssetTagPropertyModelImpl.ORDER_BY_JPQL);
1189                    }
1190    
1191                    String sql = query.toString();
1192    
1193                    Query q = session.createQuery(sql);
1194    
1195                    q.setFirstResult(0);
1196                    q.setMaxResults(2);
1197    
1198                    QueryPos qPos = QueryPos.getInstance(q);
1199    
1200                    qPos.add(companyId);
1201    
1202                    if (key != null) {
1203                            qPos.add(key);
1204                    }
1205    
1206                    if (orderByComparator != null) {
1207                            Object[] values = orderByComparator.getOrderByValues(assetTagProperty);
1208    
1209                            for (Object value : values) {
1210                                    qPos.add(value);
1211                            }
1212                    }
1213    
1214                    List<AssetTagProperty> list = q.list();
1215    
1216                    if (list.size() == 2) {
1217                            return list.get(1);
1218                    }
1219                    else {
1220                            return null;
1221                    }
1222            }
1223    
1224            public AssetTagProperty findByT_K(long tagId, String key)
1225                    throws NoSuchTagPropertyException, SystemException {
1226                    AssetTagProperty assetTagProperty = fetchByT_K(tagId, key);
1227    
1228                    if (assetTagProperty == null) {
1229                            StringBundler msg = new StringBundler(6);
1230    
1231                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1232    
1233                            msg.append("tagId=");
1234                            msg.append(tagId);
1235    
1236                            msg.append(", key=");
1237                            msg.append(key);
1238    
1239                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1240    
1241                            if (_log.isWarnEnabled()) {
1242                                    _log.warn(msg.toString());
1243                            }
1244    
1245                            throw new NoSuchTagPropertyException(msg.toString());
1246                    }
1247    
1248                    return assetTagProperty;
1249            }
1250    
1251            public AssetTagProperty fetchByT_K(long tagId, String key)
1252                    throws SystemException {
1253                    return fetchByT_K(tagId, key, true);
1254            }
1255    
1256            public AssetTagProperty fetchByT_K(long tagId, String key,
1257                    boolean retrieveFromCache) throws SystemException {
1258                    Object[] finderArgs = new Object[] { tagId, key };
1259    
1260                    Object result = null;
1261    
1262                    if (retrieveFromCache) {
1263                            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_T_K,
1264                                            finderArgs, this);
1265                    }
1266    
1267                    if (result == null) {
1268                            Session session = null;
1269    
1270                            try {
1271                                    session = openSession();
1272    
1273                                    StringBundler query = new StringBundler(4);
1274    
1275                                    query.append(_SQL_SELECT_ASSETTAGPROPERTY_WHERE);
1276    
1277                                    query.append(_FINDER_COLUMN_T_K_TAGID_2);
1278    
1279                                    if (key == null) {
1280                                            query.append(_FINDER_COLUMN_T_K_KEY_1);
1281                                    }
1282                                    else {
1283                                            if (key.equals(StringPool.BLANK)) {
1284                                                    query.append(_FINDER_COLUMN_T_K_KEY_3);
1285                                            }
1286                                            else {
1287                                                    query.append(_FINDER_COLUMN_T_K_KEY_2);
1288                                            }
1289                                    }
1290    
1291                                    query.append(AssetTagPropertyModelImpl.ORDER_BY_JPQL);
1292    
1293                                    String sql = query.toString();
1294    
1295                                    Query q = session.createQuery(sql);
1296    
1297                                    QueryPos qPos = QueryPos.getInstance(q);
1298    
1299                                    qPos.add(tagId);
1300    
1301                                    if (key != null) {
1302                                            qPos.add(key);
1303                                    }
1304    
1305                                    List<AssetTagProperty> list = q.list();
1306    
1307                                    result = list;
1308    
1309                                    AssetTagProperty assetTagProperty = null;
1310    
1311                                    if (list.isEmpty()) {
1312                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_T_K,
1313                                                    finderArgs, list);
1314                                    }
1315                                    else {
1316                                            assetTagProperty = list.get(0);
1317    
1318                                            cacheResult(assetTagProperty);
1319    
1320                                            if ((assetTagProperty.getTagId() != tagId) ||
1321                                                            (assetTagProperty.getKey() == null) ||
1322                                                            !assetTagProperty.getKey().equals(key)) {
1323                                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_T_K,
1324                                                            finderArgs, assetTagProperty);
1325                                            }
1326                                    }
1327    
1328                                    return assetTagProperty;
1329                            }
1330                            catch (Exception e) {
1331                                    throw processException(e);
1332                            }
1333                            finally {
1334                                    if (result == null) {
1335                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_T_K,
1336                                                    finderArgs, new ArrayList<AssetTagProperty>());
1337                                    }
1338    
1339                                    closeSession(session);
1340                            }
1341                    }
1342                    else {
1343                            if (result instanceof List<?>) {
1344                                    return null;
1345                            }
1346                            else {
1347                                    return (AssetTagProperty)result;
1348                            }
1349                    }
1350            }
1351    
1352            public List<AssetTagProperty> findAll() throws SystemException {
1353                    return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1354            }
1355    
1356            public List<AssetTagProperty> findAll(int start, int end)
1357                    throws SystemException {
1358                    return findAll(start, end, null);
1359            }
1360    
1361            public List<AssetTagProperty> findAll(int start, int end,
1362                    OrderByComparator orderByComparator) throws SystemException {
1363                    Object[] finderArgs = new Object[] {
1364                                    String.valueOf(start), String.valueOf(end),
1365                                    String.valueOf(orderByComparator)
1366                            };
1367    
1368                    List<AssetTagProperty> list = (List<AssetTagProperty>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
1369                                    finderArgs, this);
1370    
1371                    if (list == null) {
1372                            Session session = null;
1373    
1374                            try {
1375                                    session = openSession();
1376    
1377                                    StringBundler query = null;
1378                                    String sql = null;
1379    
1380                                    if (orderByComparator != null) {
1381                                            query = new StringBundler(2 +
1382                                                            (orderByComparator.getOrderByFields().length * 3));
1383    
1384                                            query.append(_SQL_SELECT_ASSETTAGPROPERTY);
1385    
1386                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1387                                                    orderByComparator);
1388    
1389                                            sql = query.toString();
1390                                    }
1391                                    else {
1392                                            sql = _SQL_SELECT_ASSETTAGPROPERTY.concat(AssetTagPropertyModelImpl.ORDER_BY_JPQL);
1393                                    }
1394    
1395                                    Query q = session.createQuery(sql);
1396    
1397                                    if (orderByComparator == null) {
1398                                            list = (List<AssetTagProperty>)QueryUtil.list(q,
1399                                                            getDialect(), start, end, false);
1400    
1401                                            Collections.sort(list);
1402                                    }
1403                                    else {
1404                                            list = (List<AssetTagProperty>)QueryUtil.list(q,
1405                                                            getDialect(), start, end);
1406                                    }
1407                            }
1408                            catch (Exception e) {
1409                                    throw processException(e);
1410                            }
1411                            finally {
1412                                    if (list == null) {
1413                                            list = new ArrayList<AssetTagProperty>();
1414                                    }
1415    
1416                                    cacheResult(list);
1417    
1418                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
1419    
1420                                    closeSession(session);
1421                            }
1422                    }
1423    
1424                    return list;
1425            }
1426    
1427            public void removeByCompanyId(long companyId) throws SystemException {
1428                    for (AssetTagProperty assetTagProperty : findByCompanyId(companyId)) {
1429                            remove(assetTagProperty);
1430                    }
1431            }
1432    
1433            public void removeByTagId(long tagId) throws SystemException {
1434                    for (AssetTagProperty assetTagProperty : findByTagId(tagId)) {
1435                            remove(assetTagProperty);
1436                    }
1437            }
1438    
1439            public void removeByC_K(long companyId, String key)
1440                    throws SystemException {
1441                    for (AssetTagProperty assetTagProperty : findByC_K(companyId, key)) {
1442                            remove(assetTagProperty);
1443                    }
1444            }
1445    
1446            public void removeByT_K(long tagId, String key)
1447                    throws NoSuchTagPropertyException, SystemException {
1448                    AssetTagProperty assetTagProperty = findByT_K(tagId, key);
1449    
1450                    remove(assetTagProperty);
1451            }
1452    
1453            public void removeAll() throws SystemException {
1454                    for (AssetTagProperty assetTagProperty : findAll()) {
1455                            remove(assetTagProperty);
1456                    }
1457            }
1458    
1459            public int countByCompanyId(long companyId) throws SystemException {
1460                    Object[] finderArgs = new Object[] { companyId };
1461    
1462                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_COMPANYID,
1463                                    finderArgs, this);
1464    
1465                    if (count == null) {
1466                            Session session = null;
1467    
1468                            try {
1469                                    session = openSession();
1470    
1471                                    StringBundler query = new StringBundler(2);
1472    
1473                                    query.append(_SQL_COUNT_ASSETTAGPROPERTY_WHERE);
1474    
1475                                    query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1476    
1477                                    String sql = query.toString();
1478    
1479                                    Query q = session.createQuery(sql);
1480    
1481                                    QueryPos qPos = QueryPos.getInstance(q);
1482    
1483                                    qPos.add(companyId);
1484    
1485                                    count = (Long)q.uniqueResult();
1486                            }
1487                            catch (Exception e) {
1488                                    throw processException(e);
1489                            }
1490                            finally {
1491                                    if (count == null) {
1492                                            count = Long.valueOf(0);
1493                                    }
1494    
1495                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_COMPANYID,
1496                                            finderArgs, count);
1497    
1498                                    closeSession(session);
1499                            }
1500                    }
1501    
1502                    return count.intValue();
1503            }
1504    
1505            public int countByTagId(long tagId) throws SystemException {
1506                    Object[] finderArgs = new Object[] { tagId };
1507    
1508                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_TAGID,
1509                                    finderArgs, this);
1510    
1511                    if (count == null) {
1512                            Session session = null;
1513    
1514                            try {
1515                                    session = openSession();
1516    
1517                                    StringBundler query = new StringBundler(2);
1518    
1519                                    query.append(_SQL_COUNT_ASSETTAGPROPERTY_WHERE);
1520    
1521                                    query.append(_FINDER_COLUMN_TAGID_TAGID_2);
1522    
1523                                    String sql = query.toString();
1524    
1525                                    Query q = session.createQuery(sql);
1526    
1527                                    QueryPos qPos = QueryPos.getInstance(q);
1528    
1529                                    qPos.add(tagId);
1530    
1531                                    count = (Long)q.uniqueResult();
1532                            }
1533                            catch (Exception e) {
1534                                    throw processException(e);
1535                            }
1536                            finally {
1537                                    if (count == null) {
1538                                            count = Long.valueOf(0);
1539                                    }
1540    
1541                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_TAGID,
1542                                            finderArgs, count);
1543    
1544                                    closeSession(session);
1545                            }
1546                    }
1547    
1548                    return count.intValue();
1549            }
1550    
1551            public int countByC_K(long companyId, String key) throws SystemException {
1552                    Object[] finderArgs = new Object[] { companyId, key };
1553    
1554                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_K,
1555                                    finderArgs, this);
1556    
1557                    if (count == null) {
1558                            Session session = null;
1559    
1560                            try {
1561                                    session = openSession();
1562    
1563                                    StringBundler query = new StringBundler(3);
1564    
1565                                    query.append(_SQL_COUNT_ASSETTAGPROPERTY_WHERE);
1566    
1567                                    query.append(_FINDER_COLUMN_C_K_COMPANYID_2);
1568    
1569                                    if (key == null) {
1570                                            query.append(_FINDER_COLUMN_C_K_KEY_1);
1571                                    }
1572                                    else {
1573                                            if (key.equals(StringPool.BLANK)) {
1574                                                    query.append(_FINDER_COLUMN_C_K_KEY_3);
1575                                            }
1576                                            else {
1577                                                    query.append(_FINDER_COLUMN_C_K_KEY_2);
1578                                            }
1579                                    }
1580    
1581                                    String sql = query.toString();
1582    
1583                                    Query q = session.createQuery(sql);
1584    
1585                                    QueryPos qPos = QueryPos.getInstance(q);
1586    
1587                                    qPos.add(companyId);
1588    
1589                                    if (key != null) {
1590                                            qPos.add(key);
1591                                    }
1592    
1593                                    count = (Long)q.uniqueResult();
1594                            }
1595                            catch (Exception e) {
1596                                    throw processException(e);
1597                            }
1598                            finally {
1599                                    if (count == null) {
1600                                            count = Long.valueOf(0);
1601                                    }
1602    
1603                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_K, finderArgs,
1604                                            count);
1605    
1606                                    closeSession(session);
1607                            }
1608                    }
1609    
1610                    return count.intValue();
1611            }
1612    
1613            public int countByT_K(long tagId, String key) throws SystemException {
1614                    Object[] finderArgs = new Object[] { tagId, key };
1615    
1616                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_T_K,
1617                                    finderArgs, this);
1618    
1619                    if (count == null) {
1620                            Session session = null;
1621    
1622                            try {
1623                                    session = openSession();
1624    
1625                                    StringBundler query = new StringBundler(3);
1626    
1627                                    query.append(_SQL_COUNT_ASSETTAGPROPERTY_WHERE);
1628    
1629                                    query.append(_FINDER_COLUMN_T_K_TAGID_2);
1630    
1631                                    if (key == null) {
1632                                            query.append(_FINDER_COLUMN_T_K_KEY_1);
1633                                    }
1634                                    else {
1635                                            if (key.equals(StringPool.BLANK)) {
1636                                                    query.append(_FINDER_COLUMN_T_K_KEY_3);
1637                                            }
1638                                            else {
1639                                                    query.append(_FINDER_COLUMN_T_K_KEY_2);
1640                                            }
1641                                    }
1642    
1643                                    String sql = query.toString();
1644    
1645                                    Query q = session.createQuery(sql);
1646    
1647                                    QueryPos qPos = QueryPos.getInstance(q);
1648    
1649                                    qPos.add(tagId);
1650    
1651                                    if (key != null) {
1652                                            qPos.add(key);
1653                                    }
1654    
1655                                    count = (Long)q.uniqueResult();
1656                            }
1657                            catch (Exception e) {
1658                                    throw processException(e);
1659                            }
1660                            finally {
1661                                    if (count == null) {
1662                                            count = Long.valueOf(0);
1663                                    }
1664    
1665                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_T_K, finderArgs,
1666                                            count);
1667    
1668                                    closeSession(session);
1669                            }
1670                    }
1671    
1672                    return count.intValue();
1673            }
1674    
1675            public int countAll() throws SystemException {
1676                    Object[] finderArgs = new Object[0];
1677    
1678                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
1679                                    finderArgs, this);
1680    
1681                    if (count == null) {
1682                            Session session = null;
1683    
1684                            try {
1685                                    session = openSession();
1686    
1687                                    Query q = session.createQuery(_SQL_COUNT_ASSETTAGPROPERTY);
1688    
1689                                    count = (Long)q.uniqueResult();
1690                            }
1691                            catch (Exception e) {
1692                                    throw processException(e);
1693                            }
1694                            finally {
1695                                    if (count == null) {
1696                                            count = Long.valueOf(0);
1697                                    }
1698    
1699                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
1700                                            count);
1701    
1702                                    closeSession(session);
1703                            }
1704                    }
1705    
1706                    return count.intValue();
1707            }
1708    
1709            public void afterPropertiesSet() {
1710                    String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
1711                                            com.liferay.portal.util.PropsUtil.get(
1712                                                    "value.object.listener.com.liferay.portlet.asset.model.AssetTagProperty")));
1713    
1714                    if (listenerClassNames.length > 0) {
1715                            try {
1716                                    List<ModelListener<AssetTagProperty>> listenersList = new ArrayList<ModelListener<AssetTagProperty>>();
1717    
1718                                    for (String listenerClassName : listenerClassNames) {
1719                                            listenersList.add((ModelListener<AssetTagProperty>)InstanceFactory.newInstance(
1720                                                            listenerClassName));
1721                                    }
1722    
1723                                    listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
1724                            }
1725                            catch (Exception e) {
1726                                    _log.error(e);
1727                            }
1728                    }
1729            }
1730    
1731            @BeanReference(type = AssetCategoryPersistence.class)
1732            protected AssetCategoryPersistence assetCategoryPersistence;
1733            @BeanReference(type = AssetCategoryPropertyPersistence.class)
1734            protected AssetCategoryPropertyPersistence assetCategoryPropertyPersistence;
1735            @BeanReference(type = AssetEntryPersistence.class)
1736            protected AssetEntryPersistence assetEntryPersistence;
1737            @BeanReference(type = AssetLinkPersistence.class)
1738            protected AssetLinkPersistence assetLinkPersistence;
1739            @BeanReference(type = AssetTagPersistence.class)
1740            protected AssetTagPersistence assetTagPersistence;
1741            @BeanReference(type = AssetTagPropertyPersistence.class)
1742            protected AssetTagPropertyPersistence assetTagPropertyPersistence;
1743            @BeanReference(type = AssetTagStatsPersistence.class)
1744            protected AssetTagStatsPersistence assetTagStatsPersistence;
1745            @BeanReference(type = AssetVocabularyPersistence.class)
1746            protected AssetVocabularyPersistence assetVocabularyPersistence;
1747            @BeanReference(type = ResourcePersistence.class)
1748            protected ResourcePersistence resourcePersistence;
1749            @BeanReference(type = UserPersistence.class)
1750            protected UserPersistence userPersistence;
1751            private static final String _SQL_SELECT_ASSETTAGPROPERTY = "SELECT assetTagProperty FROM AssetTagProperty assetTagProperty";
1752            private static final String _SQL_SELECT_ASSETTAGPROPERTY_WHERE = "SELECT assetTagProperty FROM AssetTagProperty assetTagProperty WHERE ";
1753            private static final String _SQL_COUNT_ASSETTAGPROPERTY = "SELECT COUNT(assetTagProperty) FROM AssetTagProperty assetTagProperty";
1754            private static final String _SQL_COUNT_ASSETTAGPROPERTY_WHERE = "SELECT COUNT(assetTagProperty) FROM AssetTagProperty assetTagProperty WHERE ";
1755            private static final String _FINDER_COLUMN_COMPANYID_COMPANYID_2 = "assetTagProperty.companyId = ?";
1756            private static final String _FINDER_COLUMN_TAGID_TAGID_2 = "assetTagProperty.tagId = ?";
1757            private static final String _FINDER_COLUMN_C_K_COMPANYID_2 = "assetTagProperty.companyId = ? AND ";
1758            private static final String _FINDER_COLUMN_C_K_KEY_1 = "assetTagProperty.key IS NULL";
1759            private static final String _FINDER_COLUMN_C_K_KEY_2 = "assetTagProperty.key = ?";
1760            private static final String _FINDER_COLUMN_C_K_KEY_3 = "(assetTagProperty.key IS NULL OR assetTagProperty.key = ?)";
1761            private static final String _FINDER_COLUMN_T_K_TAGID_2 = "assetTagProperty.tagId = ? AND ";
1762            private static final String _FINDER_COLUMN_T_K_KEY_1 = "assetTagProperty.key IS NULL";
1763            private static final String _FINDER_COLUMN_T_K_KEY_2 = "assetTagProperty.key = ?";
1764            private static final String _FINDER_COLUMN_T_K_KEY_3 = "(assetTagProperty.key IS NULL OR assetTagProperty.key = ?)";
1765            private static final String _ORDER_BY_ENTITY_ALIAS = "assetTagProperty.";
1766            private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No AssetTagProperty exists with the primary key ";
1767            private static final String _NO_SUCH_ENTITY_WITH_KEY = "No AssetTagProperty exists with the key {";
1768            private static Log _log = LogFactoryUtil.getLog(AssetTagPropertyPersistenceImpl.class);
1769    }