1   /**
2    * Copyright (c) 2000-2009 Liferay, Inc. All rights reserved.
3    *
4    * Permission is hereby granted, free of charge, to any person obtaining a copy
5    * of this software and associated documentation files (the "Software"), to deal
6    * in the Software without restriction, including without limitation the rights
7    * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8    * copies of the Software, and to permit persons to whom the Software is
9    * furnished to do so, subject to the following conditions:
10   *
11   * The above copyright notice and this permission notice shall be included in
12   * all copies or substantial portions of the Software.
13   *
14   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20   * SOFTWARE.
21   */
22  
23  package com.liferay.portlet.tags.service.persistence;
24  
25  import com.liferay.portal.NoSuchModelException;
26  import com.liferay.portal.SystemException;
27  import com.liferay.portal.kernel.annotation.BeanReference;
28  import com.liferay.portal.kernel.cache.CacheRegistry;
29  import com.liferay.portal.kernel.dao.orm.DynamicQuery;
30  import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
31  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
32  import com.liferay.portal.kernel.dao.orm.FinderPath;
33  import com.liferay.portal.kernel.dao.orm.Query;
34  import com.liferay.portal.kernel.dao.orm.QueryPos;
35  import com.liferay.portal.kernel.dao.orm.QueryUtil;
36  import com.liferay.portal.kernel.dao.orm.Session;
37  import com.liferay.portal.kernel.log.Log;
38  import com.liferay.portal.kernel.log.LogFactoryUtil;
39  import com.liferay.portal.kernel.util.GetterUtil;
40  import com.liferay.portal.kernel.util.OrderByComparator;
41  import com.liferay.portal.kernel.util.StringBundler;
42  import com.liferay.portal.kernel.util.StringPool;
43  import com.liferay.portal.kernel.util.StringUtil;
44  import com.liferay.portal.kernel.util.Validator;
45  import com.liferay.portal.model.ModelListener;
46  import com.liferay.portal.service.persistence.BatchSessionUtil;
47  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
48  
49  import com.liferay.portlet.tags.NoSuchVocabularyException;
50  import com.liferay.portlet.tags.model.TagsVocabulary;
51  import com.liferay.portlet.tags.model.impl.TagsVocabularyImpl;
52  import com.liferay.portlet.tags.model.impl.TagsVocabularyModelImpl;
53  
54  import java.io.Serializable;
55  
56  import java.util.ArrayList;
57  import java.util.Collections;
58  import java.util.List;
59  
60  /**
61   * <a href="TagsVocabularyPersistenceImpl.java.html"><b><i>View Source</i></b></a>
62   *
63   * <p>
64   * ServiceBuilder generated this class. Modifications in this class will be
65   * overwritten the next time is generated.
66   * </p>
67   *
68   * @author    Brian Wing Shun Chan
69   * @see       TagsVocabularyPersistence
70   * @see       TagsVocabularyUtil
71   * @generated
72   */
73  public class TagsVocabularyPersistenceImpl extends BasePersistenceImpl<TagsVocabulary>
74      implements TagsVocabularyPersistence {
75      public static final String FINDER_CLASS_NAME_ENTITY = TagsVocabularyImpl.class.getName();
76      public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
77          ".List";
78      public static final FinderPath FINDER_PATH_FETCH_BY_G_N = new FinderPath(TagsVocabularyModelImpl.ENTITY_CACHE_ENABLED,
79              TagsVocabularyModelImpl.FINDER_CACHE_ENABLED,
80              FINDER_CLASS_NAME_ENTITY, "fetchByG_N",
81              new String[] { Long.class.getName(), String.class.getName() });
82      public static final FinderPath FINDER_PATH_COUNT_BY_G_N = new FinderPath(TagsVocabularyModelImpl.ENTITY_CACHE_ENABLED,
83              TagsVocabularyModelImpl.FINDER_CACHE_ENABLED,
84              FINDER_CLASS_NAME_LIST, "countByG_N",
85              new String[] { Long.class.getName(), String.class.getName() });
86      public static final FinderPath FINDER_PATH_FIND_BY_G_F = new FinderPath(TagsVocabularyModelImpl.ENTITY_CACHE_ENABLED,
87              TagsVocabularyModelImpl.FINDER_CACHE_ENABLED,
88              FINDER_CLASS_NAME_LIST, "findByG_F",
89              new String[] { Long.class.getName(), Boolean.class.getName() });
90      public static final FinderPath FINDER_PATH_FIND_BY_OBC_G_F = new FinderPath(TagsVocabularyModelImpl.ENTITY_CACHE_ENABLED,
91              TagsVocabularyModelImpl.FINDER_CACHE_ENABLED,
92              FINDER_CLASS_NAME_LIST, "findByG_F",
93              new String[] {
94                  Long.class.getName(), Boolean.class.getName(),
95                  
96              "java.lang.Integer", "java.lang.Integer",
97                  "com.liferay.portal.kernel.util.OrderByComparator"
98              });
99      public static final FinderPath FINDER_PATH_COUNT_BY_G_F = new FinderPath(TagsVocabularyModelImpl.ENTITY_CACHE_ENABLED,
100             TagsVocabularyModelImpl.FINDER_CACHE_ENABLED,
101             FINDER_CLASS_NAME_LIST, "countByG_F",
102             new String[] { Long.class.getName(), Boolean.class.getName() });
103     public static final FinderPath FINDER_PATH_FIND_BY_C_F = new FinderPath(TagsVocabularyModelImpl.ENTITY_CACHE_ENABLED,
104             TagsVocabularyModelImpl.FINDER_CACHE_ENABLED,
105             FINDER_CLASS_NAME_LIST, "findByC_F",
106             new String[] { Long.class.getName(), Boolean.class.getName() });
107     public static final FinderPath FINDER_PATH_FIND_BY_OBC_C_F = new FinderPath(TagsVocabularyModelImpl.ENTITY_CACHE_ENABLED,
108             TagsVocabularyModelImpl.FINDER_CACHE_ENABLED,
109             FINDER_CLASS_NAME_LIST, "findByC_F",
110             new String[] {
111                 Long.class.getName(), Boolean.class.getName(),
112                 
113             "java.lang.Integer", "java.lang.Integer",
114                 "com.liferay.portal.kernel.util.OrderByComparator"
115             });
116     public static final FinderPath FINDER_PATH_COUNT_BY_C_F = new FinderPath(TagsVocabularyModelImpl.ENTITY_CACHE_ENABLED,
117             TagsVocabularyModelImpl.FINDER_CACHE_ENABLED,
118             FINDER_CLASS_NAME_LIST, "countByC_F",
119             new String[] { Long.class.getName(), Boolean.class.getName() });
120     public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(TagsVocabularyModelImpl.ENTITY_CACHE_ENABLED,
121             TagsVocabularyModelImpl.FINDER_CACHE_ENABLED,
122             FINDER_CLASS_NAME_LIST, "findAll", new String[0]);
123     public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(TagsVocabularyModelImpl.ENTITY_CACHE_ENABLED,
124             TagsVocabularyModelImpl.FINDER_CACHE_ENABLED,
125             FINDER_CLASS_NAME_LIST, "countAll", new String[0]);
126 
127     public void cacheResult(TagsVocabulary tagsVocabulary) {
128         EntityCacheUtil.putResult(TagsVocabularyModelImpl.ENTITY_CACHE_ENABLED,
129             TagsVocabularyImpl.class, tagsVocabulary.getPrimaryKey(),
130             tagsVocabulary);
131 
132         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_N,
133             new Object[] {
134                 new Long(tagsVocabulary.getGroupId()),
135                 
136             tagsVocabulary.getName()
137             }, tagsVocabulary);
138     }
139 
140     public void cacheResult(List<TagsVocabulary> tagsVocabularies) {
141         for (TagsVocabulary tagsVocabulary : tagsVocabularies) {
142             if (EntityCacheUtil.getResult(
143                         TagsVocabularyModelImpl.ENTITY_CACHE_ENABLED,
144                         TagsVocabularyImpl.class,
145                         tagsVocabulary.getPrimaryKey(), this) == null) {
146                 cacheResult(tagsVocabulary);
147             }
148         }
149     }
150 
151     public void clearCache() {
152         CacheRegistry.clear(TagsVocabularyImpl.class.getName());
153         EntityCacheUtil.clearCache(TagsVocabularyImpl.class.getName());
154         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
155         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
156     }
157 
158     public TagsVocabulary create(long vocabularyId) {
159         TagsVocabulary tagsVocabulary = new TagsVocabularyImpl();
160 
161         tagsVocabulary.setNew(true);
162         tagsVocabulary.setPrimaryKey(vocabularyId);
163 
164         return tagsVocabulary;
165     }
166 
167     public TagsVocabulary remove(Serializable primaryKey)
168         throws NoSuchModelException, SystemException {
169         return remove(((Long)primaryKey).longValue());
170     }
171 
172     public TagsVocabulary remove(long vocabularyId)
173         throws NoSuchVocabularyException, SystemException {
174         Session session = null;
175 
176         try {
177             session = openSession();
178 
179             TagsVocabulary tagsVocabulary = (TagsVocabulary)session.get(TagsVocabularyImpl.class,
180                     new Long(vocabularyId));
181 
182             if (tagsVocabulary == null) {
183                 if (_log.isWarnEnabled()) {
184                     _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + vocabularyId);
185                 }
186 
187                 throw new NoSuchVocabularyException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
188                     vocabularyId);
189             }
190 
191             return remove(tagsVocabulary);
192         }
193         catch (NoSuchVocabularyException nsee) {
194             throw nsee;
195         }
196         catch (Exception e) {
197             throw processException(e);
198         }
199         finally {
200             closeSession(session);
201         }
202     }
203 
204     public TagsVocabulary remove(TagsVocabulary tagsVocabulary)
205         throws SystemException {
206         for (ModelListener<TagsVocabulary> listener : listeners) {
207             listener.onBeforeRemove(tagsVocabulary);
208         }
209 
210         tagsVocabulary = removeImpl(tagsVocabulary);
211 
212         for (ModelListener<TagsVocabulary> listener : listeners) {
213             listener.onAfterRemove(tagsVocabulary);
214         }
215 
216         return tagsVocabulary;
217     }
218 
219     protected TagsVocabulary removeImpl(TagsVocabulary tagsVocabulary)
220         throws SystemException {
221         tagsVocabulary = toUnwrappedModel(tagsVocabulary);
222 
223         Session session = null;
224 
225         try {
226             session = openSession();
227 
228             if (tagsVocabulary.isCachedModel() || BatchSessionUtil.isEnabled()) {
229                 Object staleObject = session.get(TagsVocabularyImpl.class,
230                         tagsVocabulary.getPrimaryKeyObj());
231 
232                 if (staleObject != null) {
233                     session.evict(staleObject);
234                 }
235             }
236 
237             session.delete(tagsVocabulary);
238 
239             session.flush();
240         }
241         catch (Exception e) {
242             throw processException(e);
243         }
244         finally {
245             closeSession(session);
246         }
247 
248         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
249 
250         TagsVocabularyModelImpl tagsVocabularyModelImpl = (TagsVocabularyModelImpl)tagsVocabulary;
251 
252         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_N,
253             new Object[] {
254                 new Long(tagsVocabularyModelImpl.getOriginalGroupId()),
255                 
256             tagsVocabularyModelImpl.getOriginalName()
257             });
258 
259         EntityCacheUtil.removeResult(TagsVocabularyModelImpl.ENTITY_CACHE_ENABLED,
260             TagsVocabularyImpl.class, tagsVocabulary.getPrimaryKey());
261 
262         return tagsVocabulary;
263     }
264 
265     /**
266      * @deprecated Use {@link BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)}.
267      */
268     public TagsVocabulary update(TagsVocabulary tagsVocabulary)
269         throws SystemException {
270         if (_log.isWarnEnabled()) {
271             _log.warn(
272                 "Using the deprecated update(TagsVocabulary tagsVocabulary) method. Use update(TagsVocabulary tagsVocabulary, boolean merge) instead.");
273         }
274 
275         return update(tagsVocabulary, false);
276     }
277 
278     public TagsVocabulary updateImpl(
279         com.liferay.portlet.tags.model.TagsVocabulary tagsVocabulary,
280         boolean merge) throws SystemException {
281         tagsVocabulary = toUnwrappedModel(tagsVocabulary);
282 
283         boolean isNew = tagsVocabulary.isNew();
284 
285         TagsVocabularyModelImpl tagsVocabularyModelImpl = (TagsVocabularyModelImpl)tagsVocabulary;
286 
287         Session session = null;
288 
289         try {
290             session = openSession();
291 
292             BatchSessionUtil.update(session, tagsVocabulary, merge);
293 
294             tagsVocabulary.setNew(false);
295         }
296         catch (Exception e) {
297             throw processException(e);
298         }
299         finally {
300             closeSession(session);
301         }
302 
303         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
304 
305         EntityCacheUtil.putResult(TagsVocabularyModelImpl.ENTITY_CACHE_ENABLED,
306             TagsVocabularyImpl.class, tagsVocabulary.getPrimaryKey(),
307             tagsVocabulary);
308 
309         if (!isNew &&
310                 ((tagsVocabulary.getGroupId() != tagsVocabularyModelImpl.getOriginalGroupId()) ||
311                 !Validator.equals(tagsVocabulary.getName(),
312                     tagsVocabularyModelImpl.getOriginalName()))) {
313             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_N,
314                 new Object[] {
315                     new Long(tagsVocabularyModelImpl.getOriginalGroupId()),
316                     
317                 tagsVocabularyModelImpl.getOriginalName()
318                 });
319         }
320 
321         if (isNew ||
322                 ((tagsVocabulary.getGroupId() != tagsVocabularyModelImpl.getOriginalGroupId()) ||
323                 !Validator.equals(tagsVocabulary.getName(),
324                     tagsVocabularyModelImpl.getOriginalName()))) {
325             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_N,
326                 new Object[] {
327                     new Long(tagsVocabulary.getGroupId()),
328                     
329                 tagsVocabulary.getName()
330                 }, tagsVocabulary);
331         }
332 
333         return tagsVocabulary;
334     }
335 
336     protected TagsVocabulary toUnwrappedModel(TagsVocabulary tagsVocabulary) {
337         if (tagsVocabulary instanceof TagsVocabularyImpl) {
338             return tagsVocabulary;
339         }
340 
341         TagsVocabularyImpl tagsVocabularyImpl = new TagsVocabularyImpl();
342 
343         tagsVocabularyImpl.setNew(tagsVocabulary.isNew());
344         tagsVocabularyImpl.setPrimaryKey(tagsVocabulary.getPrimaryKey());
345 
346         tagsVocabularyImpl.setVocabularyId(tagsVocabulary.getVocabularyId());
347         tagsVocabularyImpl.setGroupId(tagsVocabulary.getGroupId());
348         tagsVocabularyImpl.setCompanyId(tagsVocabulary.getCompanyId());
349         tagsVocabularyImpl.setUserId(tagsVocabulary.getUserId());
350         tagsVocabularyImpl.setUserName(tagsVocabulary.getUserName());
351         tagsVocabularyImpl.setCreateDate(tagsVocabulary.getCreateDate());
352         tagsVocabularyImpl.setModifiedDate(tagsVocabulary.getModifiedDate());
353         tagsVocabularyImpl.setName(tagsVocabulary.getName());
354         tagsVocabularyImpl.setDescription(tagsVocabulary.getDescription());
355         tagsVocabularyImpl.setFolksonomy(tagsVocabulary.isFolksonomy());
356 
357         return tagsVocabularyImpl;
358     }
359 
360     public TagsVocabulary findByPrimaryKey(Serializable primaryKey)
361         throws NoSuchModelException, SystemException {
362         return findByPrimaryKey(((Long)primaryKey).longValue());
363     }
364 
365     public TagsVocabulary findByPrimaryKey(long vocabularyId)
366         throws NoSuchVocabularyException, SystemException {
367         TagsVocabulary tagsVocabulary = fetchByPrimaryKey(vocabularyId);
368 
369         if (tagsVocabulary == null) {
370             if (_log.isWarnEnabled()) {
371                 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + vocabularyId);
372             }
373 
374             throw new NoSuchVocabularyException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
375                 vocabularyId);
376         }
377 
378         return tagsVocabulary;
379     }
380 
381     public TagsVocabulary fetchByPrimaryKey(Serializable primaryKey)
382         throws SystemException {
383         return fetchByPrimaryKey(((Long)primaryKey).longValue());
384     }
385 
386     public TagsVocabulary fetchByPrimaryKey(long vocabularyId)
387         throws SystemException {
388         TagsVocabulary tagsVocabulary = (TagsVocabulary)EntityCacheUtil.getResult(TagsVocabularyModelImpl.ENTITY_CACHE_ENABLED,
389                 TagsVocabularyImpl.class, vocabularyId, this);
390 
391         if (tagsVocabulary == null) {
392             Session session = null;
393 
394             try {
395                 session = openSession();
396 
397                 tagsVocabulary = (TagsVocabulary)session.get(TagsVocabularyImpl.class,
398                         new Long(vocabularyId));
399             }
400             catch (Exception e) {
401                 throw processException(e);
402             }
403             finally {
404                 if (tagsVocabulary != null) {
405                     cacheResult(tagsVocabulary);
406                 }
407 
408                 closeSession(session);
409             }
410         }
411 
412         return tagsVocabulary;
413     }
414 
415     public TagsVocabulary findByG_N(long groupId, String name)
416         throws NoSuchVocabularyException, SystemException {
417         TagsVocabulary tagsVocabulary = fetchByG_N(groupId, name);
418 
419         if (tagsVocabulary == null) {
420             StringBundler msg = new StringBundler(6);
421 
422             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
423 
424             msg.append("groupId=");
425             msg.append(groupId);
426 
427             msg.append(", name=");
428             msg.append(name);
429 
430             msg.append(StringPool.CLOSE_CURLY_BRACE);
431 
432             if (_log.isWarnEnabled()) {
433                 _log.warn(msg.toString());
434             }
435 
436             throw new NoSuchVocabularyException(msg.toString());
437         }
438 
439         return tagsVocabulary;
440     }
441 
442     public TagsVocabulary fetchByG_N(long groupId, String name)
443         throws SystemException {
444         return fetchByG_N(groupId, name, true);
445     }
446 
447     public TagsVocabulary fetchByG_N(long groupId, String name,
448         boolean retrieveFromCache) throws SystemException {
449         Object[] finderArgs = new Object[] { new Long(groupId), name };
450 
451         Object result = null;
452 
453         if (retrieveFromCache) {
454             result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_G_N,
455                     finderArgs, this);
456         }
457 
458         if (result == null) {
459             Session session = null;
460 
461             try {
462                 session = openSession();
463 
464                 StringBundler query = new StringBundler(4);
465 
466                 query.append(_SQL_SELECT_TAGSVOCABULARY_WHERE);
467 
468                 query.append(_FINDER_COLUMN_G_N_GROUPID_2);
469 
470                 if (name == null) {
471                     query.append(_FINDER_COLUMN_G_N_NAME_1);
472                 }
473                 else {
474                     if (name.equals(StringPool.BLANK)) {
475                         query.append(_FINDER_COLUMN_G_N_NAME_3);
476                     }
477                     else {
478                         query.append(_FINDER_COLUMN_G_N_NAME_2);
479                     }
480                 }
481 
482                 query.append(TagsVocabularyModelImpl.ORDER_BY_JPQL);
483 
484                 String sql = query.toString();
485 
486                 Query q = session.createQuery(sql);
487 
488                 QueryPos qPos = QueryPos.getInstance(q);
489 
490                 qPos.add(groupId);
491 
492                 if (name != null) {
493                     qPos.add(name);
494                 }
495 
496                 List<TagsVocabulary> list = q.list();
497 
498                 result = list;
499 
500                 TagsVocabulary tagsVocabulary = null;
501 
502                 if (list.isEmpty()) {
503                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_N,
504                         finderArgs, list);
505                 }
506                 else {
507                     tagsVocabulary = list.get(0);
508 
509                     cacheResult(tagsVocabulary);
510 
511                     if ((tagsVocabulary.getGroupId() != groupId) ||
512                             (tagsVocabulary.getName() == null) ||
513                             !tagsVocabulary.getName().equals(name)) {
514                         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_N,
515                             finderArgs, tagsVocabulary);
516                     }
517                 }
518 
519                 return tagsVocabulary;
520             }
521             catch (Exception e) {
522                 throw processException(e);
523             }
524             finally {
525                 if (result == null) {
526                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_N,
527                         finderArgs, new ArrayList<TagsVocabulary>());
528                 }
529 
530                 closeSession(session);
531             }
532         }
533         else {
534             if (result instanceof List<?>) {
535                 return null;
536             }
537             else {
538                 return (TagsVocabulary)result;
539             }
540         }
541     }
542 
543     public List<TagsVocabulary> findByG_F(long groupId, boolean folksonomy)
544         throws SystemException {
545         Object[] finderArgs = new Object[] {
546                 new Long(groupId), Boolean.valueOf(folksonomy)
547             };
548 
549         List<TagsVocabulary> list = (List<TagsVocabulary>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_F,
550                 finderArgs, this);
551 
552         if (list == null) {
553             Session session = null;
554 
555             try {
556                 session = openSession();
557 
558                 StringBundler query = new StringBundler(4);
559 
560                 query.append(_SQL_SELECT_TAGSVOCABULARY_WHERE);
561 
562                 query.append(_FINDER_COLUMN_G_F_GROUPID_2);
563 
564                 query.append(_FINDER_COLUMN_G_F_FOLKSONOMY_2);
565 
566                 query.append(TagsVocabularyModelImpl.ORDER_BY_JPQL);
567 
568                 String sql = query.toString();
569 
570                 Query q = session.createQuery(sql);
571 
572                 QueryPos qPos = QueryPos.getInstance(q);
573 
574                 qPos.add(groupId);
575 
576                 qPos.add(folksonomy);
577 
578                 list = q.list();
579             }
580             catch (Exception e) {
581                 throw processException(e);
582             }
583             finally {
584                 if (list == null) {
585                     list = new ArrayList<TagsVocabulary>();
586                 }
587 
588                 cacheResult(list);
589 
590                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_F, finderArgs,
591                     list);
592 
593                 closeSession(session);
594             }
595         }
596 
597         return list;
598     }
599 
600     public List<TagsVocabulary> findByG_F(long groupId, boolean folksonomy,
601         int start, int end) throws SystemException {
602         return findByG_F(groupId, folksonomy, start, end, null);
603     }
604 
605     public List<TagsVocabulary> findByG_F(long groupId, boolean folksonomy,
606         int start, int end, OrderByComparator obc) throws SystemException {
607         Object[] finderArgs = new Object[] {
608                 new Long(groupId), Boolean.valueOf(folksonomy),
609                 
610                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
611             };
612 
613         List<TagsVocabulary> list = (List<TagsVocabulary>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_G_F,
614                 finderArgs, this);
615 
616         if (list == null) {
617             Session session = null;
618 
619             try {
620                 session = openSession();
621 
622                 StringBundler query = null;
623 
624                 if (obc != null) {
625                     query = new StringBundler(4 +
626                             (obc.getOrderByFields().length * 3));
627                 }
628                 else {
629                     query = new StringBundler(4);
630                 }
631 
632                 query.append(_SQL_SELECT_TAGSVOCABULARY_WHERE);
633 
634                 query.append(_FINDER_COLUMN_G_F_GROUPID_2);
635 
636                 query.append(_FINDER_COLUMN_G_F_FOLKSONOMY_2);
637 
638                 if (obc != null) {
639                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
640                 }
641 
642                 else {
643                     query.append(TagsVocabularyModelImpl.ORDER_BY_JPQL);
644                 }
645 
646                 String sql = query.toString();
647 
648                 Query q = session.createQuery(sql);
649 
650                 QueryPos qPos = QueryPos.getInstance(q);
651 
652                 qPos.add(groupId);
653 
654                 qPos.add(folksonomy);
655 
656                 list = (List<TagsVocabulary>)QueryUtil.list(q, getDialect(),
657                         start, end);
658             }
659             catch (Exception e) {
660                 throw processException(e);
661             }
662             finally {
663                 if (list == null) {
664                     list = new ArrayList<TagsVocabulary>();
665                 }
666 
667                 cacheResult(list);
668 
669                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_G_F,
670                     finderArgs, list);
671 
672                 closeSession(session);
673             }
674         }
675 
676         return list;
677     }
678 
679     public TagsVocabulary findByG_F_First(long groupId, boolean folksonomy,
680         OrderByComparator obc)
681         throws NoSuchVocabularyException, SystemException {
682         List<TagsVocabulary> list = findByG_F(groupId, folksonomy, 0, 1, obc);
683 
684         if (list.isEmpty()) {
685             StringBundler msg = new StringBundler(6);
686 
687             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
688 
689             msg.append("groupId=");
690             msg.append(groupId);
691 
692             msg.append(", folksonomy=");
693             msg.append(folksonomy);
694 
695             msg.append(StringPool.CLOSE_CURLY_BRACE);
696 
697             throw new NoSuchVocabularyException(msg.toString());
698         }
699         else {
700             return list.get(0);
701         }
702     }
703 
704     public TagsVocabulary findByG_F_Last(long groupId, boolean folksonomy,
705         OrderByComparator obc)
706         throws NoSuchVocabularyException, SystemException {
707         int count = countByG_F(groupId, folksonomy);
708 
709         List<TagsVocabulary> list = findByG_F(groupId, folksonomy, count - 1,
710                 count, obc);
711 
712         if (list.isEmpty()) {
713             StringBundler msg = new StringBundler(6);
714 
715             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
716 
717             msg.append("groupId=");
718             msg.append(groupId);
719 
720             msg.append(", folksonomy=");
721             msg.append(folksonomy);
722 
723             msg.append(StringPool.CLOSE_CURLY_BRACE);
724 
725             throw new NoSuchVocabularyException(msg.toString());
726         }
727         else {
728             return list.get(0);
729         }
730     }
731 
732     public TagsVocabulary[] findByG_F_PrevAndNext(long vocabularyId,
733         long groupId, boolean folksonomy, OrderByComparator obc)
734         throws NoSuchVocabularyException, SystemException {
735         TagsVocabulary tagsVocabulary = findByPrimaryKey(vocabularyId);
736 
737         int count = countByG_F(groupId, folksonomy);
738 
739         Session session = null;
740 
741         try {
742             session = openSession();
743 
744             StringBundler query = null;
745 
746             if (obc != null) {
747                 query = new StringBundler(4 +
748                         (obc.getOrderByFields().length * 3));
749             }
750             else {
751                 query = new StringBundler(4);
752             }
753 
754             query.append(_SQL_SELECT_TAGSVOCABULARY_WHERE);
755 
756             query.append(_FINDER_COLUMN_G_F_GROUPID_2);
757 
758             query.append(_FINDER_COLUMN_G_F_FOLKSONOMY_2);
759 
760             if (obc != null) {
761                 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
762             }
763 
764             else {
765                 query.append(TagsVocabularyModelImpl.ORDER_BY_JPQL);
766             }
767 
768             String sql = query.toString();
769 
770             Query q = session.createQuery(sql);
771 
772             QueryPos qPos = QueryPos.getInstance(q);
773 
774             qPos.add(groupId);
775 
776             qPos.add(folksonomy);
777 
778             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
779                     tagsVocabulary);
780 
781             TagsVocabulary[] array = new TagsVocabularyImpl[3];
782 
783             array[0] = (TagsVocabulary)objArray[0];
784             array[1] = (TagsVocabulary)objArray[1];
785             array[2] = (TagsVocabulary)objArray[2];
786 
787             return array;
788         }
789         catch (Exception e) {
790             throw processException(e);
791         }
792         finally {
793             closeSession(session);
794         }
795     }
796 
797     public List<TagsVocabulary> findByC_F(long companyId, boolean folksonomy)
798         throws SystemException {
799         Object[] finderArgs = new Object[] {
800                 new Long(companyId), Boolean.valueOf(folksonomy)
801             };
802 
803         List<TagsVocabulary> list = (List<TagsVocabulary>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_C_F,
804                 finderArgs, this);
805 
806         if (list == null) {
807             Session session = null;
808 
809             try {
810                 session = openSession();
811 
812                 StringBundler query = new StringBundler(4);
813 
814                 query.append(_SQL_SELECT_TAGSVOCABULARY_WHERE);
815 
816                 query.append(_FINDER_COLUMN_C_F_COMPANYID_2);
817 
818                 query.append(_FINDER_COLUMN_C_F_FOLKSONOMY_2);
819 
820                 query.append(TagsVocabularyModelImpl.ORDER_BY_JPQL);
821 
822                 String sql = query.toString();
823 
824                 Query q = session.createQuery(sql);
825 
826                 QueryPos qPos = QueryPos.getInstance(q);
827 
828                 qPos.add(companyId);
829 
830                 qPos.add(folksonomy);
831 
832                 list = q.list();
833             }
834             catch (Exception e) {
835                 throw processException(e);
836             }
837             finally {
838                 if (list == null) {
839                     list = new ArrayList<TagsVocabulary>();
840                 }
841 
842                 cacheResult(list);
843 
844                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_C_F, finderArgs,
845                     list);
846 
847                 closeSession(session);
848             }
849         }
850 
851         return list;
852     }
853 
854     public List<TagsVocabulary> findByC_F(long companyId, boolean folksonomy,
855         int start, int end) throws SystemException {
856         return findByC_F(companyId, folksonomy, start, end, null);
857     }
858 
859     public List<TagsVocabulary> findByC_F(long companyId, boolean folksonomy,
860         int start, int end, OrderByComparator obc) throws SystemException {
861         Object[] finderArgs = new Object[] {
862                 new Long(companyId), Boolean.valueOf(folksonomy),
863                 
864                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
865             };
866 
867         List<TagsVocabulary> list = (List<TagsVocabulary>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_C_F,
868                 finderArgs, this);
869 
870         if (list == null) {
871             Session session = null;
872 
873             try {
874                 session = openSession();
875 
876                 StringBundler query = null;
877 
878                 if (obc != null) {
879                     query = new StringBundler(4 +
880                             (obc.getOrderByFields().length * 3));
881                 }
882                 else {
883                     query = new StringBundler(4);
884                 }
885 
886                 query.append(_SQL_SELECT_TAGSVOCABULARY_WHERE);
887 
888                 query.append(_FINDER_COLUMN_C_F_COMPANYID_2);
889 
890                 query.append(_FINDER_COLUMN_C_F_FOLKSONOMY_2);
891 
892                 if (obc != null) {
893                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
894                 }
895 
896                 else {
897                     query.append(TagsVocabularyModelImpl.ORDER_BY_JPQL);
898                 }
899 
900                 String sql = query.toString();
901 
902                 Query q = session.createQuery(sql);
903 
904                 QueryPos qPos = QueryPos.getInstance(q);
905 
906                 qPos.add(companyId);
907 
908                 qPos.add(folksonomy);
909 
910                 list = (List<TagsVocabulary>)QueryUtil.list(q, getDialect(),
911                         start, end);
912             }
913             catch (Exception e) {
914                 throw processException(e);
915             }
916             finally {
917                 if (list == null) {
918                     list = new ArrayList<TagsVocabulary>();
919                 }
920 
921                 cacheResult(list);
922 
923                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_C_F,
924                     finderArgs, list);
925 
926                 closeSession(session);
927             }
928         }
929 
930         return list;
931     }
932 
933     public TagsVocabulary findByC_F_First(long companyId, boolean folksonomy,
934         OrderByComparator obc)
935         throws NoSuchVocabularyException, SystemException {
936         List<TagsVocabulary> list = findByC_F(companyId, folksonomy, 0, 1, obc);
937 
938         if (list.isEmpty()) {
939             StringBundler msg = new StringBundler(6);
940 
941             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
942 
943             msg.append("companyId=");
944             msg.append(companyId);
945 
946             msg.append(", folksonomy=");
947             msg.append(folksonomy);
948 
949             msg.append(StringPool.CLOSE_CURLY_BRACE);
950 
951             throw new NoSuchVocabularyException(msg.toString());
952         }
953         else {
954             return list.get(0);
955         }
956     }
957 
958     public TagsVocabulary findByC_F_Last(long companyId, boolean folksonomy,
959         OrderByComparator obc)
960         throws NoSuchVocabularyException, SystemException {
961         int count = countByC_F(companyId, folksonomy);
962 
963         List<TagsVocabulary> list = findByC_F(companyId, folksonomy, count - 1,
964                 count, obc);
965 
966         if (list.isEmpty()) {
967             StringBundler msg = new StringBundler(6);
968 
969             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
970 
971             msg.append("companyId=");
972             msg.append(companyId);
973 
974             msg.append(", folksonomy=");
975             msg.append(folksonomy);
976 
977             msg.append(StringPool.CLOSE_CURLY_BRACE);
978 
979             throw new NoSuchVocabularyException(msg.toString());
980         }
981         else {
982             return list.get(0);
983         }
984     }
985 
986     public TagsVocabulary[] findByC_F_PrevAndNext(long vocabularyId,
987         long companyId, boolean folksonomy, OrderByComparator obc)
988         throws NoSuchVocabularyException, SystemException {
989         TagsVocabulary tagsVocabulary = findByPrimaryKey(vocabularyId);
990 
991         int count = countByC_F(companyId, folksonomy);
992 
993         Session session = null;
994 
995         try {
996             session = openSession();
997 
998             StringBundler query = null;
999 
1000            if (obc != null) {
1001                query = new StringBundler(4 +
1002                        (obc.getOrderByFields().length * 3));
1003            }
1004            else {
1005                query = new StringBundler(4);
1006            }
1007
1008            query.append(_SQL_SELECT_TAGSVOCABULARY_WHERE);
1009
1010            query.append(_FINDER_COLUMN_C_F_COMPANYID_2);
1011
1012            query.append(_FINDER_COLUMN_C_F_FOLKSONOMY_2);
1013
1014            if (obc != null) {
1015                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
1016            }
1017
1018            else {
1019                query.append(TagsVocabularyModelImpl.ORDER_BY_JPQL);
1020            }
1021
1022            String sql = query.toString();
1023
1024            Query q = session.createQuery(sql);
1025
1026            QueryPos qPos = QueryPos.getInstance(q);
1027
1028            qPos.add(companyId);
1029
1030            qPos.add(folksonomy);
1031
1032            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1033                    tagsVocabulary);
1034
1035            TagsVocabulary[] array = new TagsVocabularyImpl[3];
1036
1037            array[0] = (TagsVocabulary)objArray[0];
1038            array[1] = (TagsVocabulary)objArray[1];
1039            array[2] = (TagsVocabulary)objArray[2];
1040
1041            return array;
1042        }
1043        catch (Exception e) {
1044            throw processException(e);
1045        }
1046        finally {
1047            closeSession(session);
1048        }
1049    }
1050
1051    public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery)
1052        throws SystemException {
1053        Session session = null;
1054
1055        try {
1056            session = openSession();
1057
1058            dynamicQuery.compile(session);
1059
1060            return dynamicQuery.list();
1061        }
1062        catch (Exception e) {
1063            throw processException(e);
1064        }
1065        finally {
1066            closeSession(session);
1067        }
1068    }
1069
1070    public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery,
1071        int start, int end) throws SystemException {
1072        Session session = null;
1073
1074        try {
1075            session = openSession();
1076
1077            dynamicQuery.setLimit(start, end);
1078
1079            dynamicQuery.compile(session);
1080
1081            return dynamicQuery.list();
1082        }
1083        catch (Exception e) {
1084            throw processException(e);
1085        }
1086        finally {
1087            closeSession(session);
1088        }
1089    }
1090
1091    public List<TagsVocabulary> findAll() throws SystemException {
1092        return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1093    }
1094
1095    public List<TagsVocabulary> findAll(int start, int end)
1096        throws SystemException {
1097        return findAll(start, end, null);
1098    }
1099
1100    public List<TagsVocabulary> findAll(int start, int end,
1101        OrderByComparator obc) throws SystemException {
1102        Object[] finderArgs = new Object[] {
1103                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1104            };
1105
1106        List<TagsVocabulary> list = (List<TagsVocabulary>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
1107                finderArgs, this);
1108
1109        if (list == null) {
1110            Session session = null;
1111
1112            try {
1113                session = openSession();
1114
1115                StringBundler query = null;
1116                String sql = null;
1117
1118                if (obc != null) {
1119                    query = new StringBundler(2 +
1120                            (obc.getOrderByFields().length * 3));
1121
1122                    query.append(_SQL_SELECT_TAGSVOCABULARY);
1123
1124                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, obc);
1125
1126                    sql = query.toString();
1127                }
1128
1129                else {
1130                    sql = _SQL_SELECT_TAGSVOCABULARY.concat(TagsVocabularyModelImpl.ORDER_BY_JPQL);
1131                }
1132
1133                Query q = session.createQuery(sql);
1134
1135                if (obc == null) {
1136                    list = (List<TagsVocabulary>)QueryUtil.list(q,
1137                            getDialect(), start, end, false);
1138
1139                    Collections.sort(list);
1140                }
1141                else {
1142                    list = (List<TagsVocabulary>)QueryUtil.list(q,
1143                            getDialect(), start, end);
1144                }
1145            }
1146            catch (Exception e) {
1147                throw processException(e);
1148            }
1149            finally {
1150                if (list == null) {
1151                    list = new ArrayList<TagsVocabulary>();
1152                }
1153
1154                cacheResult(list);
1155
1156                FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
1157
1158                closeSession(session);
1159            }
1160        }
1161
1162        return list;
1163    }
1164
1165    public void removeByG_N(long groupId, String name)
1166        throws NoSuchVocabularyException, SystemException {
1167        TagsVocabulary tagsVocabulary = findByG_N(groupId, name);
1168
1169        remove(tagsVocabulary);
1170    }
1171
1172    public void removeByG_F(long groupId, boolean folksonomy)
1173        throws SystemException {
1174        for (TagsVocabulary tagsVocabulary : findByG_F(groupId, folksonomy)) {
1175            remove(tagsVocabulary);
1176        }
1177    }
1178
1179    public void removeByC_F(long companyId, boolean folksonomy)
1180        throws SystemException {
1181        for (TagsVocabulary tagsVocabulary : findByC_F(companyId, folksonomy)) {
1182            remove(tagsVocabulary);
1183        }
1184    }
1185
1186    public void removeAll() throws SystemException {
1187        for (TagsVocabulary tagsVocabulary : findAll()) {
1188            remove(tagsVocabulary);
1189        }
1190    }
1191
1192    public int countByG_N(long groupId, String name) throws SystemException {
1193        Object[] finderArgs = new Object[] { new Long(groupId), name };
1194
1195        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_N,
1196                finderArgs, this);
1197
1198        if (count == null) {
1199            Session session = null;
1200
1201            try {
1202                session = openSession();
1203
1204                StringBundler query = new StringBundler(3);
1205
1206                query.append(_SQL_COUNT_TAGSVOCABULARY_WHERE);
1207
1208                query.append(_FINDER_COLUMN_G_N_GROUPID_2);
1209
1210                if (name == null) {
1211                    query.append(_FINDER_COLUMN_G_N_NAME_1);
1212                }
1213                else {
1214                    if (name.equals(StringPool.BLANK)) {
1215                        query.append(_FINDER_COLUMN_G_N_NAME_3);
1216                    }
1217                    else {
1218                        query.append(_FINDER_COLUMN_G_N_NAME_2);
1219                    }
1220                }
1221
1222                String sql = query.toString();
1223
1224                Query q = session.createQuery(sql);
1225
1226                QueryPos qPos = QueryPos.getInstance(q);
1227
1228                qPos.add(groupId);
1229
1230                if (name != null) {
1231                    qPos.add(name);
1232                }
1233
1234                count = (Long)q.uniqueResult();
1235            }
1236            catch (Exception e) {
1237                throw processException(e);
1238            }
1239            finally {
1240                if (count == null) {
1241                    count = Long.valueOf(0);
1242                }
1243
1244                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_N, finderArgs,
1245                    count);
1246
1247                closeSession(session);
1248            }
1249        }
1250
1251        return count.intValue();
1252    }
1253
1254    public int countByG_F(long groupId, boolean folksonomy)
1255        throws SystemException {
1256        Object[] finderArgs = new Object[] {
1257                new Long(groupId), Boolean.valueOf(folksonomy)
1258            };
1259
1260        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_F,
1261                finderArgs, this);
1262
1263        if (count == null) {
1264            Session session = null;
1265
1266            try {
1267                session = openSession();
1268
1269                StringBundler query = new StringBundler(3);
1270
1271                query.append(_SQL_COUNT_TAGSVOCABULARY_WHERE);
1272
1273                query.append(_FINDER_COLUMN_G_F_GROUPID_2);
1274
1275                query.append(_FINDER_COLUMN_G_F_FOLKSONOMY_2);
1276
1277                String sql = query.toString();
1278
1279                Query q = session.createQuery(sql);
1280
1281                QueryPos qPos = QueryPos.getInstance(q);
1282
1283                qPos.add(groupId);
1284
1285                qPos.add(folksonomy);
1286
1287                count = (Long)q.uniqueResult();
1288            }
1289            catch (Exception e) {
1290                throw processException(e);
1291            }
1292            finally {
1293                if (count == null) {
1294                    count = Long.valueOf(0);
1295                }
1296
1297                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_F, finderArgs,
1298                    count);
1299
1300                closeSession(session);
1301            }
1302        }
1303
1304        return count.intValue();
1305    }
1306
1307    public int countByC_F(long companyId, boolean folksonomy)
1308        throws SystemException {
1309        Object[] finderArgs = new Object[] {
1310                new Long(companyId), Boolean.valueOf(folksonomy)
1311            };
1312
1313        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_F,
1314                finderArgs, this);
1315
1316        if (count == null) {
1317            Session session = null;
1318
1319            try {
1320                session = openSession();
1321
1322                StringBundler query = new StringBundler(3);
1323
1324                query.append(_SQL_COUNT_TAGSVOCABULARY_WHERE);
1325
1326                query.append(_FINDER_COLUMN_C_F_COMPANYID_2);
1327
1328                query.append(_FINDER_COLUMN_C_F_FOLKSONOMY_2);
1329
1330                String sql = query.toString();
1331
1332                Query q = session.createQuery(sql);
1333
1334                QueryPos qPos = QueryPos.getInstance(q);
1335
1336                qPos.add(companyId);
1337
1338                qPos.add(folksonomy);
1339
1340                count = (Long)q.uniqueResult();
1341            }
1342            catch (Exception e) {
1343                throw processException(e);
1344            }
1345            finally {
1346                if (count == null) {
1347                    count = Long.valueOf(0);
1348                }
1349
1350                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_F, finderArgs,
1351                    count);
1352
1353                closeSession(session);
1354            }
1355        }
1356
1357        return count.intValue();
1358    }
1359
1360    public int countAll() throws SystemException {
1361        Object[] finderArgs = new Object[0];
1362
1363        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
1364                finderArgs, this);
1365
1366        if (count == null) {
1367            Session session = null;
1368
1369            try {
1370                session = openSession();
1371
1372                Query q = session.createQuery(_SQL_COUNT_TAGSVOCABULARY);
1373
1374                count = (Long)q.uniqueResult();
1375            }
1376            catch (Exception e) {
1377                throw processException(e);
1378            }
1379            finally {
1380                if (count == null) {
1381                    count = Long.valueOf(0);
1382                }
1383
1384                FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
1385                    count);
1386
1387                closeSession(session);
1388            }
1389        }
1390
1391        return count.intValue();
1392    }
1393
1394    public void afterPropertiesSet() {
1395        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
1396                    com.liferay.portal.util.PropsUtil.get(
1397                        "value.object.listener.com.liferay.portlet.tags.model.TagsVocabulary")));
1398
1399        if (listenerClassNames.length > 0) {
1400            try {
1401                List<ModelListener<TagsVocabulary>> listenersList = new ArrayList<ModelListener<TagsVocabulary>>();
1402
1403                for (String listenerClassName : listenerClassNames) {
1404                    listenersList.add((ModelListener<TagsVocabulary>)Class.forName(
1405                            listenerClassName).newInstance());
1406                }
1407
1408                listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
1409            }
1410            catch (Exception e) {
1411                _log.error(e);
1412            }
1413        }
1414    }
1415
1416    @BeanReference(name = "com.liferay.portlet.tags.service.persistence.TagsAssetPersistence")
1417    protected com.liferay.portlet.tags.service.persistence.TagsAssetPersistence tagsAssetPersistence;
1418    @BeanReference(name = "com.liferay.portlet.tags.service.persistence.TagsEntryPersistence")
1419    protected com.liferay.portlet.tags.service.persistence.TagsEntryPersistence tagsEntryPersistence;
1420    @BeanReference(name = "com.liferay.portlet.tags.service.persistence.TagsPropertyPersistence")
1421    protected com.liferay.portlet.tags.service.persistence.TagsPropertyPersistence tagsPropertyPersistence;
1422    @BeanReference(name = "com.liferay.portlet.tags.service.persistence.TagsSourcePersistence")
1423    protected com.liferay.portlet.tags.service.persistence.TagsSourcePersistence tagsSourcePersistence;
1424    @BeanReference(name = "com.liferay.portlet.tags.service.persistence.TagsVocabularyPersistence")
1425    protected com.liferay.portlet.tags.service.persistence.TagsVocabularyPersistence tagsVocabularyPersistence;
1426    @BeanReference(name = "com.liferay.portal.service.persistence.ResourcePersistence")
1427    protected com.liferay.portal.service.persistence.ResourcePersistence resourcePersistence;
1428    @BeanReference(name = "com.liferay.portal.service.persistence.UserPersistence")
1429    protected com.liferay.portal.service.persistence.UserPersistence userPersistence;
1430    private static final String _SQL_SELECT_TAGSVOCABULARY = "SELECT tagsVocabulary FROM TagsVocabulary tagsVocabulary";
1431    private static final String _SQL_SELECT_TAGSVOCABULARY_WHERE = "SELECT tagsVocabulary FROM TagsVocabulary tagsVocabulary WHERE ";
1432    private static final String _SQL_COUNT_TAGSVOCABULARY = "SELECT COUNT(tagsVocabulary) FROM TagsVocabulary tagsVocabulary";
1433    private static final String _SQL_COUNT_TAGSVOCABULARY_WHERE = "SELECT COUNT(tagsVocabulary) FROM TagsVocabulary tagsVocabulary WHERE ";
1434    private static final String _FINDER_COLUMN_G_N_GROUPID_2 = "tagsVocabulary.groupId = ? AND ";
1435    private static final String _FINDER_COLUMN_G_N_NAME_1 = "tagsVocabulary.name IS NULL";
1436    private static final String _FINDER_COLUMN_G_N_NAME_2 = "tagsVocabulary.name = ?";
1437    private static final String _FINDER_COLUMN_G_N_NAME_3 = "(tagsVocabulary.name IS NULL OR tagsVocabulary.name = ?)";
1438    private static final String _FINDER_COLUMN_G_F_GROUPID_2 = "tagsVocabulary.groupId = ? AND ";
1439    private static final String _FINDER_COLUMN_G_F_FOLKSONOMY_2 = "tagsVocabulary.folksonomy = ?";
1440    private static final String _FINDER_COLUMN_C_F_COMPANYID_2 = "tagsVocabulary.companyId = ? AND ";
1441    private static final String _FINDER_COLUMN_C_F_FOLKSONOMY_2 = "tagsVocabulary.folksonomy = ?";
1442    private static final String _ORDER_BY_ENTITY_ALIAS = "tagsVocabulary.";
1443    private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No TagsVocabulary exists with the primary key ";
1444    private static final String _NO_SUCH_ENTITY_WITH_KEY = "No TagsVocabulary exists with the key {";
1445    private static Log _log = LogFactoryUtil.getLog(TagsVocabularyPersistenceImpl.class);
1446}