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.NoSuchTagStatsException;
043    import com.liferay.portlet.asset.model.AssetTagStats;
044    import com.liferay.portlet.asset.model.impl.AssetTagStatsImpl;
045    import com.liferay.portlet.asset.model.impl.AssetTagStatsModelImpl;
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       AssetTagStatsPersistence
056     * @see       AssetTagStatsUtil
057     * @generated
058     */
059    public class AssetTagStatsPersistenceImpl extends BasePersistenceImpl<AssetTagStats>
060            implements AssetTagStatsPersistence {
061            public static final String FINDER_CLASS_NAME_ENTITY = AssetTagStatsImpl.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_TAGID = new FinderPath(AssetTagStatsModelImpl.ENTITY_CACHE_ENABLED,
065                            AssetTagStatsModelImpl.FINDER_CACHE_ENABLED,
066                            FINDER_CLASS_NAME_LIST, "findByTagId",
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_TAGID = new FinderPath(AssetTagStatsModelImpl.ENTITY_CACHE_ENABLED,
074                            AssetTagStatsModelImpl.FINDER_CACHE_ENABLED,
075                            FINDER_CLASS_NAME_LIST, "countByTagId",
076                            new String[] { Long.class.getName() });
077            public static final FinderPath FINDER_PATH_FIND_BY_CLASSNAMEID = new FinderPath(AssetTagStatsModelImpl.ENTITY_CACHE_ENABLED,
078                            AssetTagStatsModelImpl.FINDER_CACHE_ENABLED,
079                            FINDER_CLASS_NAME_LIST, "findByClassNameId",
080                            new String[] {
081                                    Long.class.getName(),
082                                    
083                            "java.lang.Integer", "java.lang.Integer",
084                                    "com.liferay.portal.kernel.util.OrderByComparator"
085                            });
086            public static final FinderPath FINDER_PATH_COUNT_BY_CLASSNAMEID = new FinderPath(AssetTagStatsModelImpl.ENTITY_CACHE_ENABLED,
087                            AssetTagStatsModelImpl.FINDER_CACHE_ENABLED,
088                            FINDER_CLASS_NAME_LIST, "countByClassNameId",
089                            new String[] { Long.class.getName() });
090            public static final FinderPath FINDER_PATH_FETCH_BY_T_C = new FinderPath(AssetTagStatsModelImpl.ENTITY_CACHE_ENABLED,
091                            AssetTagStatsModelImpl.FINDER_CACHE_ENABLED,
092                            FINDER_CLASS_NAME_ENTITY, "fetchByT_C",
093                            new String[] { Long.class.getName(), Long.class.getName() });
094            public static final FinderPath FINDER_PATH_COUNT_BY_T_C = new FinderPath(AssetTagStatsModelImpl.ENTITY_CACHE_ENABLED,
095                            AssetTagStatsModelImpl.FINDER_CACHE_ENABLED,
096                            FINDER_CLASS_NAME_LIST, "countByT_C",
097                            new String[] { Long.class.getName(), Long.class.getName() });
098            public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(AssetTagStatsModelImpl.ENTITY_CACHE_ENABLED,
099                            AssetTagStatsModelImpl.FINDER_CACHE_ENABLED,
100                            FINDER_CLASS_NAME_LIST, "findAll", new String[0]);
101            public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(AssetTagStatsModelImpl.ENTITY_CACHE_ENABLED,
102                            AssetTagStatsModelImpl.FINDER_CACHE_ENABLED,
103                            FINDER_CLASS_NAME_LIST, "countAll", new String[0]);
104    
105            public void cacheResult(AssetTagStats assetTagStats) {
106                    EntityCacheUtil.putResult(AssetTagStatsModelImpl.ENTITY_CACHE_ENABLED,
107                            AssetTagStatsImpl.class, assetTagStats.getPrimaryKey(),
108                            assetTagStats);
109    
110                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_T_C,
111                            new Object[] {
112                                    new Long(assetTagStats.getTagId()),
113                                    new Long(assetTagStats.getClassNameId())
114                            }, assetTagStats);
115            }
116    
117            public void cacheResult(List<AssetTagStats> assetTagStatses) {
118                    for (AssetTagStats assetTagStats : assetTagStatses) {
119                            if (EntityCacheUtil.getResult(
120                                                    AssetTagStatsModelImpl.ENTITY_CACHE_ENABLED,
121                                                    AssetTagStatsImpl.class, assetTagStats.getPrimaryKey(),
122                                                    this) == null) {
123                                    cacheResult(assetTagStats);
124                            }
125                    }
126            }
127    
128            public void clearCache() {
129                    CacheRegistryUtil.clear(AssetTagStatsImpl.class.getName());
130                    EntityCacheUtil.clearCache(AssetTagStatsImpl.class.getName());
131                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
132                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
133            }
134    
135            public void clearCache(AssetTagStats assetTagStats) {
136                    EntityCacheUtil.removeResult(AssetTagStatsModelImpl.ENTITY_CACHE_ENABLED,
137                            AssetTagStatsImpl.class, assetTagStats.getPrimaryKey());
138    
139                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_T_C,
140                            new Object[] {
141                                    new Long(assetTagStats.getTagId()),
142                                    new Long(assetTagStats.getClassNameId())
143                            });
144            }
145    
146            public AssetTagStats create(long tagStatsId) {
147                    AssetTagStats assetTagStats = new AssetTagStatsImpl();
148    
149                    assetTagStats.setNew(true);
150                    assetTagStats.setPrimaryKey(tagStatsId);
151    
152                    return assetTagStats;
153            }
154    
155            public AssetTagStats remove(Serializable primaryKey)
156                    throws NoSuchModelException, SystemException {
157                    return remove(((Long)primaryKey).longValue());
158            }
159    
160            public AssetTagStats remove(long tagStatsId)
161                    throws NoSuchTagStatsException, SystemException {
162                    Session session = null;
163    
164                    try {
165                            session = openSession();
166    
167                            AssetTagStats assetTagStats = (AssetTagStats)session.get(AssetTagStatsImpl.class,
168                                            new Long(tagStatsId));
169    
170                            if (assetTagStats == null) {
171                                    if (_log.isWarnEnabled()) {
172                                            _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + tagStatsId);
173                                    }
174    
175                                    throw new NoSuchTagStatsException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
176                                            tagStatsId);
177                            }
178    
179                            return remove(assetTagStats);
180                    }
181                    catch (NoSuchTagStatsException nsee) {
182                            throw nsee;
183                    }
184                    catch (Exception e) {
185                            throw processException(e);
186                    }
187                    finally {
188                            closeSession(session);
189                    }
190            }
191    
192            protected AssetTagStats removeImpl(AssetTagStats assetTagStats)
193                    throws SystemException {
194                    assetTagStats = toUnwrappedModel(assetTagStats);
195    
196                    Session session = null;
197    
198                    try {
199                            session = openSession();
200    
201                            if (assetTagStats.isCachedModel() || BatchSessionUtil.isEnabled()) {
202                                    Object staleObject = session.get(AssetTagStatsImpl.class,
203                                                    assetTagStats.getPrimaryKeyObj());
204    
205                                    if (staleObject != null) {
206                                            session.evict(staleObject);
207                                    }
208                            }
209    
210                            session.delete(assetTagStats);
211    
212                            session.flush();
213                    }
214                    catch (Exception e) {
215                            throw processException(e);
216                    }
217                    finally {
218                            closeSession(session);
219                    }
220    
221                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
222    
223                    AssetTagStatsModelImpl assetTagStatsModelImpl = (AssetTagStatsModelImpl)assetTagStats;
224    
225                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_T_C,
226                            new Object[] {
227                                    new Long(assetTagStatsModelImpl.getOriginalTagId()),
228                                    new Long(assetTagStatsModelImpl.getOriginalClassNameId())
229                            });
230    
231                    EntityCacheUtil.removeResult(AssetTagStatsModelImpl.ENTITY_CACHE_ENABLED,
232                            AssetTagStatsImpl.class, assetTagStats.getPrimaryKey());
233    
234                    return assetTagStats;
235            }
236    
237            public AssetTagStats updateImpl(
238                    com.liferay.portlet.asset.model.AssetTagStats assetTagStats,
239                    boolean merge) throws SystemException {
240                    assetTagStats = toUnwrappedModel(assetTagStats);
241    
242                    boolean isNew = assetTagStats.isNew();
243    
244                    AssetTagStatsModelImpl assetTagStatsModelImpl = (AssetTagStatsModelImpl)assetTagStats;
245    
246                    Session session = null;
247    
248                    try {
249                            session = openSession();
250    
251                            BatchSessionUtil.update(session, assetTagStats, merge);
252    
253                            assetTagStats.setNew(false);
254                    }
255                    catch (Exception e) {
256                            throw processException(e);
257                    }
258                    finally {
259                            closeSession(session);
260                    }
261    
262                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
263    
264                    EntityCacheUtil.putResult(AssetTagStatsModelImpl.ENTITY_CACHE_ENABLED,
265                            AssetTagStatsImpl.class, assetTagStats.getPrimaryKey(),
266                            assetTagStats);
267    
268                    if (!isNew &&
269                                    ((assetTagStats.getTagId() != assetTagStatsModelImpl.getOriginalTagId()) ||
270                                    (assetTagStats.getClassNameId() != assetTagStatsModelImpl.getOriginalClassNameId()))) {
271                            FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_T_C,
272                                    new Object[] {
273                                            new Long(assetTagStatsModelImpl.getOriginalTagId()),
274                                            new Long(assetTagStatsModelImpl.getOriginalClassNameId())
275                                    });
276                    }
277    
278                    if (isNew ||
279                                    ((assetTagStats.getTagId() != assetTagStatsModelImpl.getOriginalTagId()) ||
280                                    (assetTagStats.getClassNameId() != assetTagStatsModelImpl.getOriginalClassNameId()))) {
281                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_T_C,
282                                    new Object[] {
283                                            new Long(assetTagStats.getTagId()),
284                                            new Long(assetTagStats.getClassNameId())
285                                    }, assetTagStats);
286                    }
287    
288                    return assetTagStats;
289            }
290    
291            protected AssetTagStats toUnwrappedModel(AssetTagStats assetTagStats) {
292                    if (assetTagStats instanceof AssetTagStatsImpl) {
293                            return assetTagStats;
294                    }
295    
296                    AssetTagStatsImpl assetTagStatsImpl = new AssetTagStatsImpl();
297    
298                    assetTagStatsImpl.setNew(assetTagStats.isNew());
299                    assetTagStatsImpl.setPrimaryKey(assetTagStats.getPrimaryKey());
300    
301                    assetTagStatsImpl.setTagStatsId(assetTagStats.getTagStatsId());
302                    assetTagStatsImpl.setTagId(assetTagStats.getTagId());
303                    assetTagStatsImpl.setClassNameId(assetTagStats.getClassNameId());
304                    assetTagStatsImpl.setAssetCount(assetTagStats.getAssetCount());
305    
306                    return assetTagStatsImpl;
307            }
308    
309            public AssetTagStats findByPrimaryKey(Serializable primaryKey)
310                    throws NoSuchModelException, SystemException {
311                    return findByPrimaryKey(((Long)primaryKey).longValue());
312            }
313    
314            public AssetTagStats findByPrimaryKey(long tagStatsId)
315                    throws NoSuchTagStatsException, SystemException {
316                    AssetTagStats assetTagStats = fetchByPrimaryKey(tagStatsId);
317    
318                    if (assetTagStats == null) {
319                            if (_log.isWarnEnabled()) {
320                                    _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + tagStatsId);
321                            }
322    
323                            throw new NoSuchTagStatsException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
324                                    tagStatsId);
325                    }
326    
327                    return assetTagStats;
328            }
329    
330            public AssetTagStats fetchByPrimaryKey(Serializable primaryKey)
331                    throws SystemException {
332                    return fetchByPrimaryKey(((Long)primaryKey).longValue());
333            }
334    
335            public AssetTagStats fetchByPrimaryKey(long tagStatsId)
336                    throws SystemException {
337                    AssetTagStats assetTagStats = (AssetTagStats)EntityCacheUtil.getResult(AssetTagStatsModelImpl.ENTITY_CACHE_ENABLED,
338                                    AssetTagStatsImpl.class, tagStatsId, this);
339    
340                    if (assetTagStats == null) {
341                            Session session = null;
342    
343                            try {
344                                    session = openSession();
345    
346                                    assetTagStats = (AssetTagStats)session.get(AssetTagStatsImpl.class,
347                                                    new Long(tagStatsId));
348                            }
349                            catch (Exception e) {
350                                    throw processException(e);
351                            }
352                            finally {
353                                    if (assetTagStats != null) {
354                                            cacheResult(assetTagStats);
355                                    }
356    
357                                    closeSession(session);
358                            }
359                    }
360    
361                    return assetTagStats;
362            }
363    
364            public List<AssetTagStats> findByTagId(long tagId)
365                    throws SystemException {
366                    return findByTagId(tagId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
367            }
368    
369            public List<AssetTagStats> findByTagId(long tagId, int start, int end)
370                    throws SystemException {
371                    return findByTagId(tagId, start, end, null);
372            }
373    
374            public List<AssetTagStats> findByTagId(long tagId, int start, int end,
375                    OrderByComparator orderByComparator) throws SystemException {
376                    Object[] finderArgs = new Object[] {
377                                    tagId,
378                                    
379                                    String.valueOf(start), String.valueOf(end),
380                                    String.valueOf(orderByComparator)
381                            };
382    
383                    List<AssetTagStats> list = (List<AssetTagStats>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_TAGID,
384                                    finderArgs, this);
385    
386                    if (list == null) {
387                            Session session = null;
388    
389                            try {
390                                    session = openSession();
391    
392                                    StringBundler query = null;
393    
394                                    if (orderByComparator != null) {
395                                            query = new StringBundler(3 +
396                                                            (orderByComparator.getOrderByFields().length * 3));
397                                    }
398                                    else {
399                                            query = new StringBundler(3);
400                                    }
401    
402                                    query.append(_SQL_SELECT_ASSETTAGSTATS_WHERE);
403    
404                                    query.append(_FINDER_COLUMN_TAGID_TAGID_2);
405    
406                                    if (orderByComparator != null) {
407                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
408                                                    orderByComparator);
409                                    }
410    
411                                    else {
412                                            query.append(AssetTagStatsModelImpl.ORDER_BY_JPQL);
413                                    }
414    
415                                    String sql = query.toString();
416    
417                                    Query q = session.createQuery(sql);
418    
419                                    QueryPos qPos = QueryPos.getInstance(q);
420    
421                                    qPos.add(tagId);
422    
423                                    list = (List<AssetTagStats>)QueryUtil.list(q, getDialect(),
424                                                    start, end);
425                            }
426                            catch (Exception e) {
427                                    throw processException(e);
428                            }
429                            finally {
430                                    if (list == null) {
431                                            list = new ArrayList<AssetTagStats>();
432                                    }
433    
434                                    cacheResult(list);
435    
436                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_TAGID,
437                                            finderArgs, list);
438    
439                                    closeSession(session);
440                            }
441                    }
442    
443                    return list;
444            }
445    
446            public AssetTagStats findByTagId_First(long tagId,
447                    OrderByComparator orderByComparator)
448                    throws NoSuchTagStatsException, SystemException {
449                    List<AssetTagStats> list = findByTagId(tagId, 0, 1, orderByComparator);
450    
451                    if (list.isEmpty()) {
452                            StringBundler msg = new StringBundler(4);
453    
454                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
455    
456                            msg.append("tagId=");
457                            msg.append(tagId);
458    
459                            msg.append(StringPool.CLOSE_CURLY_BRACE);
460    
461                            throw new NoSuchTagStatsException(msg.toString());
462                    }
463                    else {
464                            return list.get(0);
465                    }
466            }
467    
468            public AssetTagStats findByTagId_Last(long tagId,
469                    OrderByComparator orderByComparator)
470                    throws NoSuchTagStatsException, SystemException {
471                    int count = countByTagId(tagId);
472    
473                    List<AssetTagStats> list = findByTagId(tagId, count - 1, count,
474                                    orderByComparator);
475    
476                    if (list.isEmpty()) {
477                            StringBundler msg = new StringBundler(4);
478    
479                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
480    
481                            msg.append("tagId=");
482                            msg.append(tagId);
483    
484                            msg.append(StringPool.CLOSE_CURLY_BRACE);
485    
486                            throw new NoSuchTagStatsException(msg.toString());
487                    }
488                    else {
489                            return list.get(0);
490                    }
491            }
492    
493            public AssetTagStats[] findByTagId_PrevAndNext(long tagStatsId, long tagId,
494                    OrderByComparator orderByComparator)
495                    throws NoSuchTagStatsException, SystemException {
496                    AssetTagStats assetTagStats = findByPrimaryKey(tagStatsId);
497    
498                    Session session = null;
499    
500                    try {
501                            session = openSession();
502    
503                            AssetTagStats[] array = new AssetTagStatsImpl[3];
504    
505                            array[0] = getByTagId_PrevAndNext(session, assetTagStats, tagId,
506                                            orderByComparator, true);
507    
508                            array[1] = assetTagStats;
509    
510                            array[2] = getByTagId_PrevAndNext(session, assetTagStats, tagId,
511                                            orderByComparator, false);
512    
513                            return array;
514                    }
515                    catch (Exception e) {
516                            throw processException(e);
517                    }
518                    finally {
519                            closeSession(session);
520                    }
521            }
522    
523            protected AssetTagStats getByTagId_PrevAndNext(Session session,
524                    AssetTagStats assetTagStats, long tagId,
525                    OrderByComparator orderByComparator, boolean previous) {
526                    StringBundler query = null;
527    
528                    if (orderByComparator != null) {
529                            query = new StringBundler(6 +
530                                            (orderByComparator.getOrderByFields().length * 6));
531                    }
532                    else {
533                            query = new StringBundler(3);
534                    }
535    
536                    query.append(_SQL_SELECT_ASSETTAGSTATS_WHERE);
537    
538                    query.append(_FINDER_COLUMN_TAGID_TAGID_2);
539    
540                    if (orderByComparator != null) {
541                            String[] orderByFields = orderByComparator.getOrderByFields();
542    
543                            if (orderByFields.length > 0) {
544                                    query.append(WHERE_AND);
545                            }
546    
547                            for (int i = 0; i < orderByFields.length; i++) {
548                                    query.append(_ORDER_BY_ENTITY_ALIAS);
549                                    query.append(orderByFields[i]);
550    
551                                    if ((i + 1) < orderByFields.length) {
552                                            if (orderByComparator.isAscending() ^ previous) {
553                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
554                                            }
555                                            else {
556                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
557                                            }
558                                    }
559                                    else {
560                                            if (orderByComparator.isAscending() ^ previous) {
561                                                    query.append(WHERE_GREATER_THAN);
562                                            }
563                                            else {
564                                                    query.append(WHERE_LESSER_THAN);
565                                            }
566                                    }
567                            }
568    
569                            query.append(ORDER_BY_CLAUSE);
570    
571                            for (int i = 0; i < orderByFields.length; i++) {
572                                    query.append(_ORDER_BY_ENTITY_ALIAS);
573                                    query.append(orderByFields[i]);
574    
575                                    if ((i + 1) < orderByFields.length) {
576                                            if (orderByComparator.isAscending() ^ previous) {
577                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
578                                            }
579                                            else {
580                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
581                                            }
582                                    }
583                                    else {
584                                            if (orderByComparator.isAscending() ^ previous) {
585                                                    query.append(ORDER_BY_ASC);
586                                            }
587                                            else {
588                                                    query.append(ORDER_BY_DESC);
589                                            }
590                                    }
591                            }
592                    }
593    
594                    else {
595                            query.append(AssetTagStatsModelImpl.ORDER_BY_JPQL);
596                    }
597    
598                    String sql = query.toString();
599    
600                    Query q = session.createQuery(sql);
601    
602                    q.setFirstResult(0);
603                    q.setMaxResults(2);
604    
605                    QueryPos qPos = QueryPos.getInstance(q);
606    
607                    qPos.add(tagId);
608    
609                    if (orderByComparator != null) {
610                            Object[] values = orderByComparator.getOrderByValues(assetTagStats);
611    
612                            for (Object value : values) {
613                                    qPos.add(value);
614                            }
615                    }
616    
617                    List<AssetTagStats> list = q.list();
618    
619                    if (list.size() == 2) {
620                            return list.get(1);
621                    }
622                    else {
623                            return null;
624                    }
625            }
626    
627            public List<AssetTagStats> findByClassNameId(long classNameId)
628                    throws SystemException {
629                    return findByClassNameId(classNameId, QueryUtil.ALL_POS,
630                            QueryUtil.ALL_POS, null);
631            }
632    
633            public List<AssetTagStats> findByClassNameId(long classNameId, int start,
634                    int end) throws SystemException {
635                    return findByClassNameId(classNameId, start, end, null);
636            }
637    
638            public List<AssetTagStats> findByClassNameId(long classNameId, int start,
639                    int end, OrderByComparator orderByComparator) throws SystemException {
640                    Object[] finderArgs = new Object[] {
641                                    classNameId,
642                                    
643                                    String.valueOf(start), String.valueOf(end),
644                                    String.valueOf(orderByComparator)
645                            };
646    
647                    List<AssetTagStats> list = (List<AssetTagStats>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_CLASSNAMEID,
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_ASSETTAGSTATS_WHERE);
667    
668                                    query.append(_FINDER_COLUMN_CLASSNAMEID_CLASSNAMEID_2);
669    
670                                    if (orderByComparator != null) {
671                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
672                                                    orderByComparator);
673                                    }
674    
675                                    else {
676                                            query.append(AssetTagStatsModelImpl.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(classNameId);
686    
687                                    list = (List<AssetTagStats>)QueryUtil.list(q, getDialect(),
688                                                    start, end);
689                            }
690                            catch (Exception e) {
691                                    throw processException(e);
692                            }
693                            finally {
694                                    if (list == null) {
695                                            list = new ArrayList<AssetTagStats>();
696                                    }
697    
698                                    cacheResult(list);
699    
700                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_CLASSNAMEID,
701                                            finderArgs, list);
702    
703                                    closeSession(session);
704                            }
705                    }
706    
707                    return list;
708            }
709    
710            public AssetTagStats findByClassNameId_First(long classNameId,
711                    OrderByComparator orderByComparator)
712                    throws NoSuchTagStatsException, SystemException {
713                    List<AssetTagStats> list = findByClassNameId(classNameId, 0, 1,
714                                    orderByComparator);
715    
716                    if (list.isEmpty()) {
717                            StringBundler msg = new StringBundler(4);
718    
719                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
720    
721                            msg.append("classNameId=");
722                            msg.append(classNameId);
723    
724                            msg.append(StringPool.CLOSE_CURLY_BRACE);
725    
726                            throw new NoSuchTagStatsException(msg.toString());
727                    }
728                    else {
729                            return list.get(0);
730                    }
731            }
732    
733            public AssetTagStats findByClassNameId_Last(long classNameId,
734                    OrderByComparator orderByComparator)
735                    throws NoSuchTagStatsException, SystemException {
736                    int count = countByClassNameId(classNameId);
737    
738                    List<AssetTagStats> list = findByClassNameId(classNameId, count - 1,
739                                    count, orderByComparator);
740    
741                    if (list.isEmpty()) {
742                            StringBundler msg = new StringBundler(4);
743    
744                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
745    
746                            msg.append("classNameId=");
747                            msg.append(classNameId);
748    
749                            msg.append(StringPool.CLOSE_CURLY_BRACE);
750    
751                            throw new NoSuchTagStatsException(msg.toString());
752                    }
753                    else {
754                            return list.get(0);
755                    }
756            }
757    
758            public AssetTagStats[] findByClassNameId_PrevAndNext(long tagStatsId,
759                    long classNameId, OrderByComparator orderByComparator)
760                    throws NoSuchTagStatsException, SystemException {
761                    AssetTagStats assetTagStats = findByPrimaryKey(tagStatsId);
762    
763                    Session session = null;
764    
765                    try {
766                            session = openSession();
767    
768                            AssetTagStats[] array = new AssetTagStatsImpl[3];
769    
770                            array[0] = getByClassNameId_PrevAndNext(session, assetTagStats,
771                                            classNameId, orderByComparator, true);
772    
773                            array[1] = assetTagStats;
774    
775                            array[2] = getByClassNameId_PrevAndNext(session, assetTagStats,
776                                            classNameId, orderByComparator, false);
777    
778                            return array;
779                    }
780                    catch (Exception e) {
781                            throw processException(e);
782                    }
783                    finally {
784                            closeSession(session);
785                    }
786            }
787    
788            protected AssetTagStats getByClassNameId_PrevAndNext(Session session,
789                    AssetTagStats assetTagStats, long classNameId,
790                    OrderByComparator orderByComparator, boolean previous) {
791                    StringBundler query = null;
792    
793                    if (orderByComparator != null) {
794                            query = new StringBundler(6 +
795                                            (orderByComparator.getOrderByFields().length * 6));
796                    }
797                    else {
798                            query = new StringBundler(3);
799                    }
800    
801                    query.append(_SQL_SELECT_ASSETTAGSTATS_WHERE);
802    
803                    query.append(_FINDER_COLUMN_CLASSNAMEID_CLASSNAMEID_2);
804    
805                    if (orderByComparator != null) {
806                            String[] orderByFields = orderByComparator.getOrderByFields();
807    
808                            if (orderByFields.length > 0) {
809                                    query.append(WHERE_AND);
810                            }
811    
812                            for (int i = 0; i < orderByFields.length; i++) {
813                                    query.append(_ORDER_BY_ENTITY_ALIAS);
814                                    query.append(orderByFields[i]);
815    
816                                    if ((i + 1) < orderByFields.length) {
817                                            if (orderByComparator.isAscending() ^ previous) {
818                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
819                                            }
820                                            else {
821                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
822                                            }
823                                    }
824                                    else {
825                                            if (orderByComparator.isAscending() ^ previous) {
826                                                    query.append(WHERE_GREATER_THAN);
827                                            }
828                                            else {
829                                                    query.append(WHERE_LESSER_THAN);
830                                            }
831                                    }
832                            }
833    
834                            query.append(ORDER_BY_CLAUSE);
835    
836                            for (int i = 0; i < orderByFields.length; i++) {
837                                    query.append(_ORDER_BY_ENTITY_ALIAS);
838                                    query.append(orderByFields[i]);
839    
840                                    if ((i + 1) < orderByFields.length) {
841                                            if (orderByComparator.isAscending() ^ previous) {
842                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
843                                            }
844                                            else {
845                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
846                                            }
847                                    }
848                                    else {
849                                            if (orderByComparator.isAscending() ^ previous) {
850                                                    query.append(ORDER_BY_ASC);
851                                            }
852                                            else {
853                                                    query.append(ORDER_BY_DESC);
854                                            }
855                                    }
856                            }
857                    }
858    
859                    else {
860                            query.append(AssetTagStatsModelImpl.ORDER_BY_JPQL);
861                    }
862    
863                    String sql = query.toString();
864    
865                    Query q = session.createQuery(sql);
866    
867                    q.setFirstResult(0);
868                    q.setMaxResults(2);
869    
870                    QueryPos qPos = QueryPos.getInstance(q);
871    
872                    qPos.add(classNameId);
873    
874                    if (orderByComparator != null) {
875                            Object[] values = orderByComparator.getOrderByValues(assetTagStats);
876    
877                            for (Object value : values) {
878                                    qPos.add(value);
879                            }
880                    }
881    
882                    List<AssetTagStats> list = q.list();
883    
884                    if (list.size() == 2) {
885                            return list.get(1);
886                    }
887                    else {
888                            return null;
889                    }
890            }
891    
892            public AssetTagStats findByT_C(long tagId, long classNameId)
893                    throws NoSuchTagStatsException, SystemException {
894                    AssetTagStats assetTagStats = fetchByT_C(tagId, classNameId);
895    
896                    if (assetTagStats == null) {
897                            StringBundler msg = new StringBundler(6);
898    
899                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
900    
901                            msg.append("tagId=");
902                            msg.append(tagId);
903    
904                            msg.append(", classNameId=");
905                            msg.append(classNameId);
906    
907                            msg.append(StringPool.CLOSE_CURLY_BRACE);
908    
909                            if (_log.isWarnEnabled()) {
910                                    _log.warn(msg.toString());
911                            }
912    
913                            throw new NoSuchTagStatsException(msg.toString());
914                    }
915    
916                    return assetTagStats;
917            }
918    
919            public AssetTagStats fetchByT_C(long tagId, long classNameId)
920                    throws SystemException {
921                    return fetchByT_C(tagId, classNameId, true);
922            }
923    
924            public AssetTagStats fetchByT_C(long tagId, long classNameId,
925                    boolean retrieveFromCache) throws SystemException {
926                    Object[] finderArgs = new Object[] { tagId, classNameId };
927    
928                    Object result = null;
929    
930                    if (retrieveFromCache) {
931                            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_T_C,
932                                            finderArgs, this);
933                    }
934    
935                    if (result == null) {
936                            Session session = null;
937    
938                            try {
939                                    session = openSession();
940    
941                                    StringBundler query = new StringBundler(4);
942    
943                                    query.append(_SQL_SELECT_ASSETTAGSTATS_WHERE);
944    
945                                    query.append(_FINDER_COLUMN_T_C_TAGID_2);
946    
947                                    query.append(_FINDER_COLUMN_T_C_CLASSNAMEID_2);
948    
949                                    query.append(AssetTagStatsModelImpl.ORDER_BY_JPQL);
950    
951                                    String sql = query.toString();
952    
953                                    Query q = session.createQuery(sql);
954    
955                                    QueryPos qPos = QueryPos.getInstance(q);
956    
957                                    qPos.add(tagId);
958    
959                                    qPos.add(classNameId);
960    
961                                    List<AssetTagStats> list = q.list();
962    
963                                    result = list;
964    
965                                    AssetTagStats assetTagStats = null;
966    
967                                    if (list.isEmpty()) {
968                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_T_C,
969                                                    finderArgs, list);
970                                    }
971                                    else {
972                                            assetTagStats = list.get(0);
973    
974                                            cacheResult(assetTagStats);
975    
976                                            if ((assetTagStats.getTagId() != tagId) ||
977                                                            (assetTagStats.getClassNameId() != classNameId)) {
978                                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_T_C,
979                                                            finderArgs, assetTagStats);
980                                            }
981                                    }
982    
983                                    return assetTagStats;
984                            }
985                            catch (Exception e) {
986                                    throw processException(e);
987                            }
988                            finally {
989                                    if (result == null) {
990                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_T_C,
991                                                    finderArgs, new ArrayList<AssetTagStats>());
992                                    }
993    
994                                    closeSession(session);
995                            }
996                    }
997                    else {
998                            if (result instanceof List<?>) {
999                                    return null;
1000                            }
1001                            else {
1002                                    return (AssetTagStats)result;
1003                            }
1004                    }
1005            }
1006    
1007            public List<AssetTagStats> findAll() throws SystemException {
1008                    return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1009            }
1010    
1011            public List<AssetTagStats> findAll(int start, int end)
1012                    throws SystemException {
1013                    return findAll(start, end, null);
1014            }
1015    
1016            public List<AssetTagStats> findAll(int start, int end,
1017                    OrderByComparator orderByComparator) throws SystemException {
1018                    Object[] finderArgs = new Object[] {
1019                                    String.valueOf(start), String.valueOf(end),
1020                                    String.valueOf(orderByComparator)
1021                            };
1022    
1023                    List<AssetTagStats> list = (List<AssetTagStats>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
1024                                    finderArgs, this);
1025    
1026                    if (list == null) {
1027                            Session session = null;
1028    
1029                            try {
1030                                    session = openSession();
1031    
1032                                    StringBundler query = null;
1033                                    String sql = null;
1034    
1035                                    if (orderByComparator != null) {
1036                                            query = new StringBundler(2 +
1037                                                            (orderByComparator.getOrderByFields().length * 3));
1038    
1039                                            query.append(_SQL_SELECT_ASSETTAGSTATS);
1040    
1041                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1042                                                    orderByComparator);
1043    
1044                                            sql = query.toString();
1045                                    }
1046                                    else {
1047                                            sql = _SQL_SELECT_ASSETTAGSTATS.concat(AssetTagStatsModelImpl.ORDER_BY_JPQL);
1048                                    }
1049    
1050                                    Query q = session.createQuery(sql);
1051    
1052                                    if (orderByComparator == null) {
1053                                            list = (List<AssetTagStats>)QueryUtil.list(q, getDialect(),
1054                                                            start, end, false);
1055    
1056                                            Collections.sort(list);
1057                                    }
1058                                    else {
1059                                            list = (List<AssetTagStats>)QueryUtil.list(q, getDialect(),
1060                                                            start, end);
1061                                    }
1062                            }
1063                            catch (Exception e) {
1064                                    throw processException(e);
1065                            }
1066                            finally {
1067                                    if (list == null) {
1068                                            list = new ArrayList<AssetTagStats>();
1069                                    }
1070    
1071                                    cacheResult(list);
1072    
1073                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
1074    
1075                                    closeSession(session);
1076                            }
1077                    }
1078    
1079                    return list;
1080            }
1081    
1082            public void removeByTagId(long tagId) throws SystemException {
1083                    for (AssetTagStats assetTagStats : findByTagId(tagId)) {
1084                            remove(assetTagStats);
1085                    }
1086            }
1087    
1088            public void removeByClassNameId(long classNameId) throws SystemException {
1089                    for (AssetTagStats assetTagStats : findByClassNameId(classNameId)) {
1090                            remove(assetTagStats);
1091                    }
1092            }
1093    
1094            public void removeByT_C(long tagId, long classNameId)
1095                    throws NoSuchTagStatsException, SystemException {
1096                    AssetTagStats assetTagStats = findByT_C(tagId, classNameId);
1097    
1098                    remove(assetTagStats);
1099            }
1100    
1101            public void removeAll() throws SystemException {
1102                    for (AssetTagStats assetTagStats : findAll()) {
1103                            remove(assetTagStats);
1104                    }
1105            }
1106    
1107            public int countByTagId(long tagId) throws SystemException {
1108                    Object[] finderArgs = new Object[] { tagId };
1109    
1110                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_TAGID,
1111                                    finderArgs, this);
1112    
1113                    if (count == null) {
1114                            Session session = null;
1115    
1116                            try {
1117                                    session = openSession();
1118    
1119                                    StringBundler query = new StringBundler(2);
1120    
1121                                    query.append(_SQL_COUNT_ASSETTAGSTATS_WHERE);
1122    
1123                                    query.append(_FINDER_COLUMN_TAGID_TAGID_2);
1124    
1125                                    String sql = query.toString();
1126    
1127                                    Query q = session.createQuery(sql);
1128    
1129                                    QueryPos qPos = QueryPos.getInstance(q);
1130    
1131                                    qPos.add(tagId);
1132    
1133                                    count = (Long)q.uniqueResult();
1134                            }
1135                            catch (Exception e) {
1136                                    throw processException(e);
1137                            }
1138                            finally {
1139                                    if (count == null) {
1140                                            count = Long.valueOf(0);
1141                                    }
1142    
1143                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_TAGID,
1144                                            finderArgs, count);
1145    
1146                                    closeSession(session);
1147                            }
1148                    }
1149    
1150                    return count.intValue();
1151            }
1152    
1153            public int countByClassNameId(long classNameId) throws SystemException {
1154                    Object[] finderArgs = new Object[] { classNameId };
1155    
1156                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_CLASSNAMEID,
1157                                    finderArgs, this);
1158    
1159                    if (count == null) {
1160                            Session session = null;
1161    
1162                            try {
1163                                    session = openSession();
1164    
1165                                    StringBundler query = new StringBundler(2);
1166    
1167                                    query.append(_SQL_COUNT_ASSETTAGSTATS_WHERE);
1168    
1169                                    query.append(_FINDER_COLUMN_CLASSNAMEID_CLASSNAMEID_2);
1170    
1171                                    String sql = query.toString();
1172    
1173                                    Query q = session.createQuery(sql);
1174    
1175                                    QueryPos qPos = QueryPos.getInstance(q);
1176    
1177                                    qPos.add(classNameId);
1178    
1179                                    count = (Long)q.uniqueResult();
1180                            }
1181                            catch (Exception e) {
1182                                    throw processException(e);
1183                            }
1184                            finally {
1185                                    if (count == null) {
1186                                            count = Long.valueOf(0);
1187                                    }
1188    
1189                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_CLASSNAMEID,
1190                                            finderArgs, count);
1191    
1192                                    closeSession(session);
1193                            }
1194                    }
1195    
1196                    return count.intValue();
1197            }
1198    
1199            public int countByT_C(long tagId, long classNameId)
1200                    throws SystemException {
1201                    Object[] finderArgs = new Object[] { tagId, classNameId };
1202    
1203                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_T_C,
1204                                    finderArgs, this);
1205    
1206                    if (count == null) {
1207                            Session session = null;
1208    
1209                            try {
1210                                    session = openSession();
1211    
1212                                    StringBundler query = new StringBundler(3);
1213    
1214                                    query.append(_SQL_COUNT_ASSETTAGSTATS_WHERE);
1215    
1216                                    query.append(_FINDER_COLUMN_T_C_TAGID_2);
1217    
1218                                    query.append(_FINDER_COLUMN_T_C_CLASSNAMEID_2);
1219    
1220                                    String sql = query.toString();
1221    
1222                                    Query q = session.createQuery(sql);
1223    
1224                                    QueryPos qPos = QueryPos.getInstance(q);
1225    
1226                                    qPos.add(tagId);
1227    
1228                                    qPos.add(classNameId);
1229    
1230                                    count = (Long)q.uniqueResult();
1231                            }
1232                            catch (Exception e) {
1233                                    throw processException(e);
1234                            }
1235                            finally {
1236                                    if (count == null) {
1237                                            count = Long.valueOf(0);
1238                                    }
1239    
1240                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_T_C, finderArgs,
1241                                            count);
1242    
1243                                    closeSession(session);
1244                            }
1245                    }
1246    
1247                    return count.intValue();
1248            }
1249    
1250            public int countAll() throws SystemException {
1251                    Object[] finderArgs = new Object[0];
1252    
1253                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
1254                                    finderArgs, this);
1255    
1256                    if (count == null) {
1257                            Session session = null;
1258    
1259                            try {
1260                                    session = openSession();
1261    
1262                                    Query q = session.createQuery(_SQL_COUNT_ASSETTAGSTATS);
1263    
1264                                    count = (Long)q.uniqueResult();
1265                            }
1266                            catch (Exception e) {
1267                                    throw processException(e);
1268                            }
1269                            finally {
1270                                    if (count == null) {
1271                                            count = Long.valueOf(0);
1272                                    }
1273    
1274                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
1275                                            count);
1276    
1277                                    closeSession(session);
1278                            }
1279                    }
1280    
1281                    return count.intValue();
1282            }
1283    
1284            public void afterPropertiesSet() {
1285                    String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
1286                                            com.liferay.portal.util.PropsUtil.get(
1287                                                    "value.object.listener.com.liferay.portlet.asset.model.AssetTagStats")));
1288    
1289                    if (listenerClassNames.length > 0) {
1290                            try {
1291                                    List<ModelListener<AssetTagStats>> listenersList = new ArrayList<ModelListener<AssetTagStats>>();
1292    
1293                                    for (String listenerClassName : listenerClassNames) {
1294                                            listenersList.add((ModelListener<AssetTagStats>)InstanceFactory.newInstance(
1295                                                            listenerClassName));
1296                                    }
1297    
1298                                    listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
1299                            }
1300                            catch (Exception e) {
1301                                    _log.error(e);
1302                            }
1303                    }
1304            }
1305    
1306            @BeanReference(type = AssetCategoryPersistence.class)
1307            protected AssetCategoryPersistence assetCategoryPersistence;
1308            @BeanReference(type = AssetCategoryPropertyPersistence.class)
1309            protected AssetCategoryPropertyPersistence assetCategoryPropertyPersistence;
1310            @BeanReference(type = AssetEntryPersistence.class)
1311            protected AssetEntryPersistence assetEntryPersistence;
1312            @BeanReference(type = AssetLinkPersistence.class)
1313            protected AssetLinkPersistence assetLinkPersistence;
1314            @BeanReference(type = AssetTagPersistence.class)
1315            protected AssetTagPersistence assetTagPersistence;
1316            @BeanReference(type = AssetTagPropertyPersistence.class)
1317            protected AssetTagPropertyPersistence assetTagPropertyPersistence;
1318            @BeanReference(type = AssetTagStatsPersistence.class)
1319            protected AssetTagStatsPersistence assetTagStatsPersistence;
1320            @BeanReference(type = AssetVocabularyPersistence.class)
1321            protected AssetVocabularyPersistence assetVocabularyPersistence;
1322            @BeanReference(type = ResourcePersistence.class)
1323            protected ResourcePersistence resourcePersistence;
1324            @BeanReference(type = UserPersistence.class)
1325            protected UserPersistence userPersistence;
1326            private static final String _SQL_SELECT_ASSETTAGSTATS = "SELECT assetTagStats FROM AssetTagStats assetTagStats";
1327            private static final String _SQL_SELECT_ASSETTAGSTATS_WHERE = "SELECT assetTagStats FROM AssetTagStats assetTagStats WHERE ";
1328            private static final String _SQL_COUNT_ASSETTAGSTATS = "SELECT COUNT(assetTagStats) FROM AssetTagStats assetTagStats";
1329            private static final String _SQL_COUNT_ASSETTAGSTATS_WHERE = "SELECT COUNT(assetTagStats) FROM AssetTagStats assetTagStats WHERE ";
1330            private static final String _FINDER_COLUMN_TAGID_TAGID_2 = "assetTagStats.tagId = ?";
1331            private static final String _FINDER_COLUMN_CLASSNAMEID_CLASSNAMEID_2 = "assetTagStats.classNameId = ?";
1332            private static final String _FINDER_COLUMN_T_C_TAGID_2 = "assetTagStats.tagId = ? AND ";
1333            private static final String _FINDER_COLUMN_T_C_CLASSNAMEID_2 = "assetTagStats.classNameId = ?";
1334            private static final String _ORDER_BY_ENTITY_ALIAS = "assetTagStats.";
1335            private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No AssetTagStats exists with the primary key ";
1336            private static final String _NO_SUCH_ENTITY_WITH_KEY = "No AssetTagStats exists with the key {";
1337            private static Log _log = LogFactoryUtil.getLog(AssetTagStatsPersistenceImpl.class);
1338    }