1
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
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
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}