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