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