001
014
015 package com.liferay.portlet.journal.service.persistence;
016
017 import com.liferay.portal.kernel.cache.CacheRegistryUtil;
018 import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
019 import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
020 import com.liferay.portal.kernel.dao.orm.FinderPath;
021 import com.liferay.portal.kernel.dao.orm.Query;
022 import com.liferay.portal.kernel.dao.orm.QueryPos;
023 import com.liferay.portal.kernel.dao.orm.QueryUtil;
024 import com.liferay.portal.kernel.dao.orm.SQLQuery;
025 import com.liferay.portal.kernel.dao.orm.Session;
026 import com.liferay.portal.kernel.exception.SystemException;
027 import com.liferay.portal.kernel.log.Log;
028 import com.liferay.portal.kernel.log.LogFactoryUtil;
029 import com.liferay.portal.kernel.util.GetterUtil;
030 import com.liferay.portal.kernel.util.InstanceFactory;
031 import com.liferay.portal.kernel.util.OrderByComparator;
032 import com.liferay.portal.kernel.util.SetUtil;
033 import com.liferay.portal.kernel.util.StringBundler;
034 import com.liferay.portal.kernel.util.StringPool;
035 import com.liferay.portal.kernel.util.StringUtil;
036 import com.liferay.portal.kernel.util.UnmodifiableList;
037 import com.liferay.portal.kernel.util.Validator;
038 import com.liferay.portal.kernel.uuid.PortalUUIDUtil;
039 import com.liferay.portal.model.CacheModel;
040 import com.liferay.portal.model.ModelListener;
041 import com.liferay.portal.security.permission.InlineSQLHelperUtil;
042 import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
043
044 import com.liferay.portlet.journal.NoSuchFeedException;
045 import com.liferay.portlet.journal.model.JournalFeed;
046 import com.liferay.portlet.journal.model.impl.JournalFeedImpl;
047 import com.liferay.portlet.journal.model.impl.JournalFeedModelImpl;
048
049 import java.io.Serializable;
050
051 import java.util.ArrayList;
052 import java.util.Collections;
053 import java.util.List;
054 import java.util.Set;
055
056
068 public class JournalFeedPersistenceImpl extends BasePersistenceImpl<JournalFeed>
069 implements JournalFeedPersistence {
070
075 public static final String FINDER_CLASS_NAME_ENTITY = JournalFeedImpl.class.getName();
076 public static final String FINDER_CLASS_NAME_LIST_WITH_PAGINATION = FINDER_CLASS_NAME_ENTITY +
077 ".List1";
078 public static final String FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION = FINDER_CLASS_NAME_ENTITY +
079 ".List2";
080 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_ALL = new FinderPath(JournalFeedModelImpl.ENTITY_CACHE_ENABLED,
081 JournalFeedModelImpl.FINDER_CACHE_ENABLED, JournalFeedImpl.class,
082 FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findAll", new String[0]);
083 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL = new FinderPath(JournalFeedModelImpl.ENTITY_CACHE_ENABLED,
084 JournalFeedModelImpl.FINDER_CACHE_ENABLED, JournalFeedImpl.class,
085 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findAll", new String[0]);
086 public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(JournalFeedModelImpl.ENTITY_CACHE_ENABLED,
087 JournalFeedModelImpl.FINDER_CACHE_ENABLED, Long.class,
088 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countAll", new String[0]);
089 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_UUID = new FinderPath(JournalFeedModelImpl.ENTITY_CACHE_ENABLED,
090 JournalFeedModelImpl.FINDER_CACHE_ENABLED, JournalFeedImpl.class,
091 FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByUuid",
092 new String[] {
093 String.class.getName(),
094
095 Integer.class.getName(), Integer.class.getName(),
096 OrderByComparator.class.getName()
097 });
098 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID = new FinderPath(JournalFeedModelImpl.ENTITY_CACHE_ENABLED,
099 JournalFeedModelImpl.FINDER_CACHE_ENABLED, JournalFeedImpl.class,
100 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByUuid",
101 new String[] { String.class.getName() },
102 JournalFeedModelImpl.UUID_COLUMN_BITMASK |
103 JournalFeedModelImpl.FEEDID_COLUMN_BITMASK);
104 public static final FinderPath FINDER_PATH_COUNT_BY_UUID = new FinderPath(JournalFeedModelImpl.ENTITY_CACHE_ENABLED,
105 JournalFeedModelImpl.FINDER_CACHE_ENABLED, Long.class,
106 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByUuid",
107 new String[] { String.class.getName() });
108
109
116 @Override
117 public List<JournalFeed> findByUuid(String uuid) throws SystemException {
118 return findByUuid(uuid, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
119 }
120
121
134 @Override
135 public List<JournalFeed> findByUuid(String uuid, int start, int end)
136 throws SystemException {
137 return findByUuid(uuid, start, end, null);
138 }
139
140
154 @Override
155 public List<JournalFeed> findByUuid(String uuid, int start, int end,
156 OrderByComparator orderByComparator) throws SystemException {
157 boolean pagination = true;
158 FinderPath finderPath = null;
159 Object[] finderArgs = null;
160
161 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
162 (orderByComparator == null)) {
163 pagination = false;
164 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID;
165 finderArgs = new Object[] { uuid };
166 }
167 else {
168 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_UUID;
169 finderArgs = new Object[] { uuid, start, end, orderByComparator };
170 }
171
172 List<JournalFeed> list = (List<JournalFeed>)FinderCacheUtil.getResult(finderPath,
173 finderArgs, this);
174
175 if ((list != null) && !list.isEmpty()) {
176 for (JournalFeed journalFeed : list) {
177 if (!Validator.equals(uuid, journalFeed.getUuid())) {
178 list = null;
179
180 break;
181 }
182 }
183 }
184
185 if (list == null) {
186 StringBundler query = null;
187
188 if (orderByComparator != null) {
189 query = new StringBundler(3 +
190 (orderByComparator.getOrderByFields().length * 3));
191 }
192 else {
193 query = new StringBundler(3);
194 }
195
196 query.append(_SQL_SELECT_JOURNALFEED_WHERE);
197
198 boolean bindUuid = false;
199
200 if (uuid == null) {
201 query.append(_FINDER_COLUMN_UUID_UUID_1);
202 }
203 else if (uuid.equals(StringPool.BLANK)) {
204 query.append(_FINDER_COLUMN_UUID_UUID_3);
205 }
206 else {
207 bindUuid = true;
208
209 query.append(_FINDER_COLUMN_UUID_UUID_2);
210 }
211
212 if (orderByComparator != null) {
213 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
214 orderByComparator);
215 }
216 else
217 if (pagination) {
218 query.append(JournalFeedModelImpl.ORDER_BY_JPQL);
219 }
220
221 String sql = query.toString();
222
223 Session session = null;
224
225 try {
226 session = openSession();
227
228 Query q = session.createQuery(sql);
229
230 QueryPos qPos = QueryPos.getInstance(q);
231
232 if (bindUuid) {
233 qPos.add(uuid);
234 }
235
236 if (!pagination) {
237 list = (List<JournalFeed>)QueryUtil.list(q, getDialect(),
238 start, end, false);
239
240 Collections.sort(list);
241
242 list = new UnmodifiableList<JournalFeed>(list);
243 }
244 else {
245 list = (List<JournalFeed>)QueryUtil.list(q, getDialect(),
246 start, end);
247 }
248
249 cacheResult(list);
250
251 FinderCacheUtil.putResult(finderPath, finderArgs, list);
252 }
253 catch (Exception e) {
254 FinderCacheUtil.removeResult(finderPath, finderArgs);
255
256 throw processException(e);
257 }
258 finally {
259 closeSession(session);
260 }
261 }
262
263 return list;
264 }
265
266
275 @Override
276 public JournalFeed findByUuid_First(String uuid,
277 OrderByComparator orderByComparator)
278 throws NoSuchFeedException, SystemException {
279 JournalFeed journalFeed = fetchByUuid_First(uuid, orderByComparator);
280
281 if (journalFeed != null) {
282 return journalFeed;
283 }
284
285 StringBundler msg = new StringBundler(4);
286
287 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
288
289 msg.append("uuid=");
290 msg.append(uuid);
291
292 msg.append(StringPool.CLOSE_CURLY_BRACE);
293
294 throw new NoSuchFeedException(msg.toString());
295 }
296
297
305 @Override
306 public JournalFeed fetchByUuid_First(String uuid,
307 OrderByComparator orderByComparator) throws SystemException {
308 List<JournalFeed> list = findByUuid(uuid, 0, 1, orderByComparator);
309
310 if (!list.isEmpty()) {
311 return list.get(0);
312 }
313
314 return null;
315 }
316
317
326 @Override
327 public JournalFeed findByUuid_Last(String uuid,
328 OrderByComparator orderByComparator)
329 throws NoSuchFeedException, SystemException {
330 JournalFeed journalFeed = fetchByUuid_Last(uuid, orderByComparator);
331
332 if (journalFeed != null) {
333 return journalFeed;
334 }
335
336 StringBundler msg = new StringBundler(4);
337
338 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
339
340 msg.append("uuid=");
341 msg.append(uuid);
342
343 msg.append(StringPool.CLOSE_CURLY_BRACE);
344
345 throw new NoSuchFeedException(msg.toString());
346 }
347
348
356 @Override
357 public JournalFeed fetchByUuid_Last(String uuid,
358 OrderByComparator orderByComparator) throws SystemException {
359 int count = countByUuid(uuid);
360
361 if (count == 0) {
362 return null;
363 }
364
365 List<JournalFeed> list = findByUuid(uuid, count - 1, count,
366 orderByComparator);
367
368 if (!list.isEmpty()) {
369 return list.get(0);
370 }
371
372 return null;
373 }
374
375
385 @Override
386 public JournalFeed[] findByUuid_PrevAndNext(long id, String uuid,
387 OrderByComparator orderByComparator)
388 throws NoSuchFeedException, SystemException {
389 JournalFeed journalFeed = findByPrimaryKey(id);
390
391 Session session = null;
392
393 try {
394 session = openSession();
395
396 JournalFeed[] array = new JournalFeedImpl[3];
397
398 array[0] = getByUuid_PrevAndNext(session, journalFeed, uuid,
399 orderByComparator, true);
400
401 array[1] = journalFeed;
402
403 array[2] = getByUuid_PrevAndNext(session, journalFeed, uuid,
404 orderByComparator, false);
405
406 return array;
407 }
408 catch (Exception e) {
409 throw processException(e);
410 }
411 finally {
412 closeSession(session);
413 }
414 }
415
416 protected JournalFeed getByUuid_PrevAndNext(Session session,
417 JournalFeed journalFeed, String uuid,
418 OrderByComparator orderByComparator, boolean previous) {
419 StringBundler query = null;
420
421 if (orderByComparator != null) {
422 query = new StringBundler(6 +
423 (orderByComparator.getOrderByFields().length * 6));
424 }
425 else {
426 query = new StringBundler(3);
427 }
428
429 query.append(_SQL_SELECT_JOURNALFEED_WHERE);
430
431 boolean bindUuid = false;
432
433 if (uuid == null) {
434 query.append(_FINDER_COLUMN_UUID_UUID_1);
435 }
436 else if (uuid.equals(StringPool.BLANK)) {
437 query.append(_FINDER_COLUMN_UUID_UUID_3);
438 }
439 else {
440 bindUuid = true;
441
442 query.append(_FINDER_COLUMN_UUID_UUID_2);
443 }
444
445 if (orderByComparator != null) {
446 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
447
448 if (orderByConditionFields.length > 0) {
449 query.append(WHERE_AND);
450 }
451
452 for (int i = 0; i < orderByConditionFields.length; i++) {
453 query.append(_ORDER_BY_ENTITY_ALIAS);
454 query.append(orderByConditionFields[i]);
455
456 if ((i + 1) < orderByConditionFields.length) {
457 if (orderByComparator.isAscending() ^ previous) {
458 query.append(WHERE_GREATER_THAN_HAS_NEXT);
459 }
460 else {
461 query.append(WHERE_LESSER_THAN_HAS_NEXT);
462 }
463 }
464 else {
465 if (orderByComparator.isAscending() ^ previous) {
466 query.append(WHERE_GREATER_THAN);
467 }
468 else {
469 query.append(WHERE_LESSER_THAN);
470 }
471 }
472 }
473
474 query.append(ORDER_BY_CLAUSE);
475
476 String[] orderByFields = orderByComparator.getOrderByFields();
477
478 for (int i = 0; i < orderByFields.length; i++) {
479 query.append(_ORDER_BY_ENTITY_ALIAS);
480 query.append(orderByFields[i]);
481
482 if ((i + 1) < orderByFields.length) {
483 if (orderByComparator.isAscending() ^ previous) {
484 query.append(ORDER_BY_ASC_HAS_NEXT);
485 }
486 else {
487 query.append(ORDER_BY_DESC_HAS_NEXT);
488 }
489 }
490 else {
491 if (orderByComparator.isAscending() ^ previous) {
492 query.append(ORDER_BY_ASC);
493 }
494 else {
495 query.append(ORDER_BY_DESC);
496 }
497 }
498 }
499 }
500 else {
501 query.append(JournalFeedModelImpl.ORDER_BY_JPQL);
502 }
503
504 String sql = query.toString();
505
506 Query q = session.createQuery(sql);
507
508 q.setFirstResult(0);
509 q.setMaxResults(2);
510
511 QueryPos qPos = QueryPos.getInstance(q);
512
513 if (bindUuid) {
514 qPos.add(uuid);
515 }
516
517 if (orderByComparator != null) {
518 Object[] values = orderByComparator.getOrderByConditionValues(journalFeed);
519
520 for (Object value : values) {
521 qPos.add(value);
522 }
523 }
524
525 List<JournalFeed> list = q.list();
526
527 if (list.size() == 2) {
528 return list.get(1);
529 }
530 else {
531 return null;
532 }
533 }
534
535
541 @Override
542 public void removeByUuid(String uuid) throws SystemException {
543 for (JournalFeed journalFeed : findByUuid(uuid, QueryUtil.ALL_POS,
544 QueryUtil.ALL_POS, null)) {
545 remove(journalFeed);
546 }
547 }
548
549
556 @Override
557 public int countByUuid(String uuid) throws SystemException {
558 FinderPath finderPath = FINDER_PATH_COUNT_BY_UUID;
559
560 Object[] finderArgs = new Object[] { uuid };
561
562 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
563 this);
564
565 if (count == null) {
566 StringBundler query = new StringBundler(2);
567
568 query.append(_SQL_COUNT_JOURNALFEED_WHERE);
569
570 boolean bindUuid = false;
571
572 if (uuid == null) {
573 query.append(_FINDER_COLUMN_UUID_UUID_1);
574 }
575 else if (uuid.equals(StringPool.BLANK)) {
576 query.append(_FINDER_COLUMN_UUID_UUID_3);
577 }
578 else {
579 bindUuid = true;
580
581 query.append(_FINDER_COLUMN_UUID_UUID_2);
582 }
583
584 String sql = query.toString();
585
586 Session session = null;
587
588 try {
589 session = openSession();
590
591 Query q = session.createQuery(sql);
592
593 QueryPos qPos = QueryPos.getInstance(q);
594
595 if (bindUuid) {
596 qPos.add(uuid);
597 }
598
599 count = (Long)q.uniqueResult();
600
601 FinderCacheUtil.putResult(finderPath, finderArgs, count);
602 }
603 catch (Exception e) {
604 FinderCacheUtil.removeResult(finderPath, finderArgs);
605
606 throw processException(e);
607 }
608 finally {
609 closeSession(session);
610 }
611 }
612
613 return count.intValue();
614 }
615
616 private static final String _FINDER_COLUMN_UUID_UUID_1 = "journalFeed.uuid IS NULL";
617 private static final String _FINDER_COLUMN_UUID_UUID_2 = "journalFeed.uuid = ?";
618 private static final String _FINDER_COLUMN_UUID_UUID_3 = "(journalFeed.uuid IS NULL OR journalFeed.uuid = '')";
619 public static final FinderPath FINDER_PATH_FETCH_BY_UUID_G = new FinderPath(JournalFeedModelImpl.ENTITY_CACHE_ENABLED,
620 JournalFeedModelImpl.FINDER_CACHE_ENABLED, JournalFeedImpl.class,
621 FINDER_CLASS_NAME_ENTITY, "fetchByUUID_G",
622 new String[] { String.class.getName(), Long.class.getName() },
623 JournalFeedModelImpl.UUID_COLUMN_BITMASK |
624 JournalFeedModelImpl.GROUPID_COLUMN_BITMASK);
625 public static final FinderPath FINDER_PATH_COUNT_BY_UUID_G = new FinderPath(JournalFeedModelImpl.ENTITY_CACHE_ENABLED,
626 JournalFeedModelImpl.FINDER_CACHE_ENABLED, Long.class,
627 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByUUID_G",
628 new String[] { String.class.getName(), Long.class.getName() });
629
630
639 @Override
640 public JournalFeed findByUUID_G(String uuid, long groupId)
641 throws NoSuchFeedException, SystemException {
642 JournalFeed journalFeed = fetchByUUID_G(uuid, groupId);
643
644 if (journalFeed == null) {
645 StringBundler msg = new StringBundler(6);
646
647 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
648
649 msg.append("uuid=");
650 msg.append(uuid);
651
652 msg.append(", groupId=");
653 msg.append(groupId);
654
655 msg.append(StringPool.CLOSE_CURLY_BRACE);
656
657 if (_log.isWarnEnabled()) {
658 _log.warn(msg.toString());
659 }
660
661 throw new NoSuchFeedException(msg.toString());
662 }
663
664 return journalFeed;
665 }
666
667
675 @Override
676 public JournalFeed fetchByUUID_G(String uuid, long groupId)
677 throws SystemException {
678 return fetchByUUID_G(uuid, groupId, true);
679 }
680
681
690 @Override
691 public JournalFeed fetchByUUID_G(String uuid, long groupId,
692 boolean retrieveFromCache) throws SystemException {
693 Object[] finderArgs = new Object[] { uuid, groupId };
694
695 Object result = null;
696
697 if (retrieveFromCache) {
698 result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_UUID_G,
699 finderArgs, this);
700 }
701
702 if (result instanceof JournalFeed) {
703 JournalFeed journalFeed = (JournalFeed)result;
704
705 if (!Validator.equals(uuid, journalFeed.getUuid()) ||
706 (groupId != journalFeed.getGroupId())) {
707 result = null;
708 }
709 }
710
711 if (result == null) {
712 StringBundler query = new StringBundler(4);
713
714 query.append(_SQL_SELECT_JOURNALFEED_WHERE);
715
716 boolean bindUuid = false;
717
718 if (uuid == null) {
719 query.append(_FINDER_COLUMN_UUID_G_UUID_1);
720 }
721 else if (uuid.equals(StringPool.BLANK)) {
722 query.append(_FINDER_COLUMN_UUID_G_UUID_3);
723 }
724 else {
725 bindUuid = true;
726
727 query.append(_FINDER_COLUMN_UUID_G_UUID_2);
728 }
729
730 query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
731
732 String sql = query.toString();
733
734 Session session = null;
735
736 try {
737 session = openSession();
738
739 Query q = session.createQuery(sql);
740
741 QueryPos qPos = QueryPos.getInstance(q);
742
743 if (bindUuid) {
744 qPos.add(uuid);
745 }
746
747 qPos.add(groupId);
748
749 List<JournalFeed> list = q.list();
750
751 if (list.isEmpty()) {
752 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
753 finderArgs, list);
754 }
755 else {
756 JournalFeed journalFeed = list.get(0);
757
758 result = journalFeed;
759
760 cacheResult(journalFeed);
761
762 if ((journalFeed.getUuid() == null) ||
763 !journalFeed.getUuid().equals(uuid) ||
764 (journalFeed.getGroupId() != groupId)) {
765 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
766 finderArgs, journalFeed);
767 }
768 }
769 }
770 catch (Exception e) {
771 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
772 finderArgs);
773
774 throw processException(e);
775 }
776 finally {
777 closeSession(session);
778 }
779 }
780
781 if (result instanceof List<?>) {
782 return null;
783 }
784 else {
785 return (JournalFeed)result;
786 }
787 }
788
789
797 @Override
798 public JournalFeed removeByUUID_G(String uuid, long groupId)
799 throws NoSuchFeedException, SystemException {
800 JournalFeed journalFeed = findByUUID_G(uuid, groupId);
801
802 return remove(journalFeed);
803 }
804
805
813 @Override
814 public int countByUUID_G(String uuid, long groupId)
815 throws SystemException {
816 FinderPath finderPath = FINDER_PATH_COUNT_BY_UUID_G;
817
818 Object[] finderArgs = new Object[] { uuid, groupId };
819
820 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
821 this);
822
823 if (count == null) {
824 StringBundler query = new StringBundler(3);
825
826 query.append(_SQL_COUNT_JOURNALFEED_WHERE);
827
828 boolean bindUuid = false;
829
830 if (uuid == null) {
831 query.append(_FINDER_COLUMN_UUID_G_UUID_1);
832 }
833 else if (uuid.equals(StringPool.BLANK)) {
834 query.append(_FINDER_COLUMN_UUID_G_UUID_3);
835 }
836 else {
837 bindUuid = true;
838
839 query.append(_FINDER_COLUMN_UUID_G_UUID_2);
840 }
841
842 query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
843
844 String sql = query.toString();
845
846 Session session = null;
847
848 try {
849 session = openSession();
850
851 Query q = session.createQuery(sql);
852
853 QueryPos qPos = QueryPos.getInstance(q);
854
855 if (bindUuid) {
856 qPos.add(uuid);
857 }
858
859 qPos.add(groupId);
860
861 count = (Long)q.uniqueResult();
862
863 FinderCacheUtil.putResult(finderPath, finderArgs, count);
864 }
865 catch (Exception e) {
866 FinderCacheUtil.removeResult(finderPath, finderArgs);
867
868 throw processException(e);
869 }
870 finally {
871 closeSession(session);
872 }
873 }
874
875 return count.intValue();
876 }
877
878 private static final String _FINDER_COLUMN_UUID_G_UUID_1 = "journalFeed.uuid IS NULL AND ";
879 private static final String _FINDER_COLUMN_UUID_G_UUID_2 = "journalFeed.uuid = ? AND ";
880 private static final String _FINDER_COLUMN_UUID_G_UUID_3 = "(journalFeed.uuid IS NULL OR journalFeed.uuid = '') AND ";
881 private static final String _FINDER_COLUMN_UUID_G_GROUPID_2 = "journalFeed.groupId = ?";
882 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_UUID_C = new FinderPath(JournalFeedModelImpl.ENTITY_CACHE_ENABLED,
883 JournalFeedModelImpl.FINDER_CACHE_ENABLED, JournalFeedImpl.class,
884 FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByUuid_C",
885 new String[] {
886 String.class.getName(), Long.class.getName(),
887
888 Integer.class.getName(), Integer.class.getName(),
889 OrderByComparator.class.getName()
890 });
891 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C =
892 new FinderPath(JournalFeedModelImpl.ENTITY_CACHE_ENABLED,
893 JournalFeedModelImpl.FINDER_CACHE_ENABLED, JournalFeedImpl.class,
894 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByUuid_C",
895 new String[] { String.class.getName(), Long.class.getName() },
896 JournalFeedModelImpl.UUID_COLUMN_BITMASK |
897 JournalFeedModelImpl.COMPANYID_COLUMN_BITMASK |
898 JournalFeedModelImpl.FEEDID_COLUMN_BITMASK);
899 public static final FinderPath FINDER_PATH_COUNT_BY_UUID_C = new FinderPath(JournalFeedModelImpl.ENTITY_CACHE_ENABLED,
900 JournalFeedModelImpl.FINDER_CACHE_ENABLED, Long.class,
901 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByUuid_C",
902 new String[] { String.class.getName(), Long.class.getName() });
903
904
912 @Override
913 public List<JournalFeed> findByUuid_C(String uuid, long companyId)
914 throws SystemException {
915 return findByUuid_C(uuid, companyId, QueryUtil.ALL_POS,
916 QueryUtil.ALL_POS, null);
917 }
918
919
933 @Override
934 public List<JournalFeed> findByUuid_C(String uuid, long companyId,
935 int start, int end) throws SystemException {
936 return findByUuid_C(uuid, companyId, start, end, null);
937 }
938
939
954 @Override
955 public List<JournalFeed> findByUuid_C(String uuid, long companyId,
956 int start, int end, OrderByComparator orderByComparator)
957 throws SystemException {
958 boolean pagination = true;
959 FinderPath finderPath = null;
960 Object[] finderArgs = null;
961
962 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
963 (orderByComparator == null)) {
964 pagination = false;
965 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C;
966 finderArgs = new Object[] { uuid, companyId };
967 }
968 else {
969 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_UUID_C;
970 finderArgs = new Object[] {
971 uuid, companyId,
972
973 start, end, orderByComparator
974 };
975 }
976
977 List<JournalFeed> list = (List<JournalFeed>)FinderCacheUtil.getResult(finderPath,
978 finderArgs, this);
979
980 if ((list != null) && !list.isEmpty()) {
981 for (JournalFeed journalFeed : list) {
982 if (!Validator.equals(uuid, journalFeed.getUuid()) ||
983 (companyId != journalFeed.getCompanyId())) {
984 list = null;
985
986 break;
987 }
988 }
989 }
990
991 if (list == null) {
992 StringBundler query = null;
993
994 if (orderByComparator != null) {
995 query = new StringBundler(4 +
996 (orderByComparator.getOrderByFields().length * 3));
997 }
998 else {
999 query = new StringBundler(4);
1000 }
1001
1002 query.append(_SQL_SELECT_JOURNALFEED_WHERE);
1003
1004 boolean bindUuid = false;
1005
1006 if (uuid == null) {
1007 query.append(_FINDER_COLUMN_UUID_C_UUID_1);
1008 }
1009 else if (uuid.equals(StringPool.BLANK)) {
1010 query.append(_FINDER_COLUMN_UUID_C_UUID_3);
1011 }
1012 else {
1013 bindUuid = true;
1014
1015 query.append(_FINDER_COLUMN_UUID_C_UUID_2);
1016 }
1017
1018 query.append(_FINDER_COLUMN_UUID_C_COMPANYID_2);
1019
1020 if (orderByComparator != null) {
1021 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1022 orderByComparator);
1023 }
1024 else
1025 if (pagination) {
1026 query.append(JournalFeedModelImpl.ORDER_BY_JPQL);
1027 }
1028
1029 String sql = query.toString();
1030
1031 Session session = null;
1032
1033 try {
1034 session = openSession();
1035
1036 Query q = session.createQuery(sql);
1037
1038 QueryPos qPos = QueryPos.getInstance(q);
1039
1040 if (bindUuid) {
1041 qPos.add(uuid);
1042 }
1043
1044 qPos.add(companyId);
1045
1046 if (!pagination) {
1047 list = (List<JournalFeed>)QueryUtil.list(q, getDialect(),
1048 start, end, false);
1049
1050 Collections.sort(list);
1051
1052 list = new UnmodifiableList<JournalFeed>(list);
1053 }
1054 else {
1055 list = (List<JournalFeed>)QueryUtil.list(q, getDialect(),
1056 start, end);
1057 }
1058
1059 cacheResult(list);
1060
1061 FinderCacheUtil.putResult(finderPath, finderArgs, list);
1062 }
1063 catch (Exception e) {
1064 FinderCacheUtil.removeResult(finderPath, finderArgs);
1065
1066 throw processException(e);
1067 }
1068 finally {
1069 closeSession(session);
1070 }
1071 }
1072
1073 return list;
1074 }
1075
1076
1086 @Override
1087 public JournalFeed findByUuid_C_First(String uuid, long companyId,
1088 OrderByComparator orderByComparator)
1089 throws NoSuchFeedException, SystemException {
1090 JournalFeed journalFeed = fetchByUuid_C_First(uuid, companyId,
1091 orderByComparator);
1092
1093 if (journalFeed != null) {
1094 return journalFeed;
1095 }
1096
1097 StringBundler msg = new StringBundler(6);
1098
1099 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1100
1101 msg.append("uuid=");
1102 msg.append(uuid);
1103
1104 msg.append(", companyId=");
1105 msg.append(companyId);
1106
1107 msg.append(StringPool.CLOSE_CURLY_BRACE);
1108
1109 throw new NoSuchFeedException(msg.toString());
1110 }
1111
1112
1121 @Override
1122 public JournalFeed fetchByUuid_C_First(String uuid, long companyId,
1123 OrderByComparator orderByComparator) throws SystemException {
1124 List<JournalFeed> list = findByUuid_C(uuid, companyId, 0, 1,
1125 orderByComparator);
1126
1127 if (!list.isEmpty()) {
1128 return list.get(0);
1129 }
1130
1131 return null;
1132 }
1133
1134
1144 @Override
1145 public JournalFeed findByUuid_C_Last(String uuid, long companyId,
1146 OrderByComparator orderByComparator)
1147 throws NoSuchFeedException, SystemException {
1148 JournalFeed journalFeed = fetchByUuid_C_Last(uuid, companyId,
1149 orderByComparator);
1150
1151 if (journalFeed != null) {
1152 return journalFeed;
1153 }
1154
1155 StringBundler msg = new StringBundler(6);
1156
1157 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1158
1159 msg.append("uuid=");
1160 msg.append(uuid);
1161
1162 msg.append(", companyId=");
1163 msg.append(companyId);
1164
1165 msg.append(StringPool.CLOSE_CURLY_BRACE);
1166
1167 throw new NoSuchFeedException(msg.toString());
1168 }
1169
1170
1179 @Override
1180 public JournalFeed fetchByUuid_C_Last(String uuid, long companyId,
1181 OrderByComparator orderByComparator) throws SystemException {
1182 int count = countByUuid_C(uuid, companyId);
1183
1184 if (count == 0) {
1185 return null;
1186 }
1187
1188 List<JournalFeed> list = findByUuid_C(uuid, companyId, count - 1,
1189 count, orderByComparator);
1190
1191 if (!list.isEmpty()) {
1192 return list.get(0);
1193 }
1194
1195 return null;
1196 }
1197
1198
1209 @Override
1210 public JournalFeed[] findByUuid_C_PrevAndNext(long id, String uuid,
1211 long companyId, OrderByComparator orderByComparator)
1212 throws NoSuchFeedException, SystemException {
1213 JournalFeed journalFeed = findByPrimaryKey(id);
1214
1215 Session session = null;
1216
1217 try {
1218 session = openSession();
1219
1220 JournalFeed[] array = new JournalFeedImpl[3];
1221
1222 array[0] = getByUuid_C_PrevAndNext(session, journalFeed, uuid,
1223 companyId, orderByComparator, true);
1224
1225 array[1] = journalFeed;
1226
1227 array[2] = getByUuid_C_PrevAndNext(session, journalFeed, uuid,
1228 companyId, orderByComparator, false);
1229
1230 return array;
1231 }
1232 catch (Exception e) {
1233 throw processException(e);
1234 }
1235 finally {
1236 closeSession(session);
1237 }
1238 }
1239
1240 protected JournalFeed getByUuid_C_PrevAndNext(Session session,
1241 JournalFeed journalFeed, String uuid, long companyId,
1242 OrderByComparator orderByComparator, boolean previous) {
1243 StringBundler query = null;
1244
1245 if (orderByComparator != null) {
1246 query = new StringBundler(6 +
1247 (orderByComparator.getOrderByFields().length * 6));
1248 }
1249 else {
1250 query = new StringBundler(3);
1251 }
1252
1253 query.append(_SQL_SELECT_JOURNALFEED_WHERE);
1254
1255 boolean bindUuid = false;
1256
1257 if (uuid == null) {
1258 query.append(_FINDER_COLUMN_UUID_C_UUID_1);
1259 }
1260 else if (uuid.equals(StringPool.BLANK)) {
1261 query.append(_FINDER_COLUMN_UUID_C_UUID_3);
1262 }
1263 else {
1264 bindUuid = true;
1265
1266 query.append(_FINDER_COLUMN_UUID_C_UUID_2);
1267 }
1268
1269 query.append(_FINDER_COLUMN_UUID_C_COMPANYID_2);
1270
1271 if (orderByComparator != null) {
1272 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
1273
1274 if (orderByConditionFields.length > 0) {
1275 query.append(WHERE_AND);
1276 }
1277
1278 for (int i = 0; i < orderByConditionFields.length; i++) {
1279 query.append(_ORDER_BY_ENTITY_ALIAS);
1280 query.append(orderByConditionFields[i]);
1281
1282 if ((i + 1) < orderByConditionFields.length) {
1283 if (orderByComparator.isAscending() ^ previous) {
1284 query.append(WHERE_GREATER_THAN_HAS_NEXT);
1285 }
1286 else {
1287 query.append(WHERE_LESSER_THAN_HAS_NEXT);
1288 }
1289 }
1290 else {
1291 if (orderByComparator.isAscending() ^ previous) {
1292 query.append(WHERE_GREATER_THAN);
1293 }
1294 else {
1295 query.append(WHERE_LESSER_THAN);
1296 }
1297 }
1298 }
1299
1300 query.append(ORDER_BY_CLAUSE);
1301
1302 String[] orderByFields = orderByComparator.getOrderByFields();
1303
1304 for (int i = 0; i < orderByFields.length; i++) {
1305 query.append(_ORDER_BY_ENTITY_ALIAS);
1306 query.append(orderByFields[i]);
1307
1308 if ((i + 1) < orderByFields.length) {
1309 if (orderByComparator.isAscending() ^ previous) {
1310 query.append(ORDER_BY_ASC_HAS_NEXT);
1311 }
1312 else {
1313 query.append(ORDER_BY_DESC_HAS_NEXT);
1314 }
1315 }
1316 else {
1317 if (orderByComparator.isAscending() ^ previous) {
1318 query.append(ORDER_BY_ASC);
1319 }
1320 else {
1321 query.append(ORDER_BY_DESC);
1322 }
1323 }
1324 }
1325 }
1326 else {
1327 query.append(JournalFeedModelImpl.ORDER_BY_JPQL);
1328 }
1329
1330 String sql = query.toString();
1331
1332 Query q = session.createQuery(sql);
1333
1334 q.setFirstResult(0);
1335 q.setMaxResults(2);
1336
1337 QueryPos qPos = QueryPos.getInstance(q);
1338
1339 if (bindUuid) {
1340 qPos.add(uuid);
1341 }
1342
1343 qPos.add(companyId);
1344
1345 if (orderByComparator != null) {
1346 Object[] values = orderByComparator.getOrderByConditionValues(journalFeed);
1347
1348 for (Object value : values) {
1349 qPos.add(value);
1350 }
1351 }
1352
1353 List<JournalFeed> list = q.list();
1354
1355 if (list.size() == 2) {
1356 return list.get(1);
1357 }
1358 else {
1359 return null;
1360 }
1361 }
1362
1363
1370 @Override
1371 public void removeByUuid_C(String uuid, long companyId)
1372 throws SystemException {
1373 for (JournalFeed journalFeed : findByUuid_C(uuid, companyId,
1374 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
1375 remove(journalFeed);
1376 }
1377 }
1378
1379
1387 @Override
1388 public int countByUuid_C(String uuid, long companyId)
1389 throws SystemException {
1390 FinderPath finderPath = FINDER_PATH_COUNT_BY_UUID_C;
1391
1392 Object[] finderArgs = new Object[] { uuid, companyId };
1393
1394 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
1395 this);
1396
1397 if (count == null) {
1398 StringBundler query = new StringBundler(3);
1399
1400 query.append(_SQL_COUNT_JOURNALFEED_WHERE);
1401
1402 boolean bindUuid = false;
1403
1404 if (uuid == null) {
1405 query.append(_FINDER_COLUMN_UUID_C_UUID_1);
1406 }
1407 else if (uuid.equals(StringPool.BLANK)) {
1408 query.append(_FINDER_COLUMN_UUID_C_UUID_3);
1409 }
1410 else {
1411 bindUuid = true;
1412
1413 query.append(_FINDER_COLUMN_UUID_C_UUID_2);
1414 }
1415
1416 query.append(_FINDER_COLUMN_UUID_C_COMPANYID_2);
1417
1418 String sql = query.toString();
1419
1420 Session session = null;
1421
1422 try {
1423 session = openSession();
1424
1425 Query q = session.createQuery(sql);
1426
1427 QueryPos qPos = QueryPos.getInstance(q);
1428
1429 if (bindUuid) {
1430 qPos.add(uuid);
1431 }
1432
1433 qPos.add(companyId);
1434
1435 count = (Long)q.uniqueResult();
1436
1437 FinderCacheUtil.putResult(finderPath, finderArgs, count);
1438 }
1439 catch (Exception e) {
1440 FinderCacheUtil.removeResult(finderPath, finderArgs);
1441
1442 throw processException(e);
1443 }
1444 finally {
1445 closeSession(session);
1446 }
1447 }
1448
1449 return count.intValue();
1450 }
1451
1452 private static final String _FINDER_COLUMN_UUID_C_UUID_1 = "journalFeed.uuid IS NULL AND ";
1453 private static final String _FINDER_COLUMN_UUID_C_UUID_2 = "journalFeed.uuid = ? AND ";
1454 private static final String _FINDER_COLUMN_UUID_C_UUID_3 = "(journalFeed.uuid IS NULL OR journalFeed.uuid = '') AND ";
1455 private static final String _FINDER_COLUMN_UUID_C_COMPANYID_2 = "journalFeed.companyId = ?";
1456 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_GROUPID = new FinderPath(JournalFeedModelImpl.ENTITY_CACHE_ENABLED,
1457 JournalFeedModelImpl.FINDER_CACHE_ENABLED, JournalFeedImpl.class,
1458 FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByGroupId",
1459 new String[] {
1460 Long.class.getName(),
1461
1462 Integer.class.getName(), Integer.class.getName(),
1463 OrderByComparator.class.getName()
1464 });
1465 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID =
1466 new FinderPath(JournalFeedModelImpl.ENTITY_CACHE_ENABLED,
1467 JournalFeedModelImpl.FINDER_CACHE_ENABLED, JournalFeedImpl.class,
1468 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByGroupId",
1469 new String[] { Long.class.getName() },
1470 JournalFeedModelImpl.GROUPID_COLUMN_BITMASK |
1471 JournalFeedModelImpl.FEEDID_COLUMN_BITMASK);
1472 public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(JournalFeedModelImpl.ENTITY_CACHE_ENABLED,
1473 JournalFeedModelImpl.FINDER_CACHE_ENABLED, Long.class,
1474 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByGroupId",
1475 new String[] { Long.class.getName() });
1476
1477
1484 @Override
1485 public List<JournalFeed> findByGroupId(long groupId)
1486 throws SystemException {
1487 return findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1488 }
1489
1490
1503 @Override
1504 public List<JournalFeed> findByGroupId(long groupId, int start, int end)
1505 throws SystemException {
1506 return findByGroupId(groupId, start, end, null);
1507 }
1508
1509
1523 @Override
1524 public List<JournalFeed> findByGroupId(long groupId, int start, int end,
1525 OrderByComparator orderByComparator) throws SystemException {
1526 boolean pagination = true;
1527 FinderPath finderPath = null;
1528 Object[] finderArgs = null;
1529
1530 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
1531 (orderByComparator == null)) {
1532 pagination = false;
1533 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID;
1534 finderArgs = new Object[] { groupId };
1535 }
1536 else {
1537 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_GROUPID;
1538 finderArgs = new Object[] { groupId, start, end, orderByComparator };
1539 }
1540
1541 List<JournalFeed> list = (List<JournalFeed>)FinderCacheUtil.getResult(finderPath,
1542 finderArgs, this);
1543
1544 if ((list != null) && !list.isEmpty()) {
1545 for (JournalFeed journalFeed : list) {
1546 if ((groupId != journalFeed.getGroupId())) {
1547 list = null;
1548
1549 break;
1550 }
1551 }
1552 }
1553
1554 if (list == null) {
1555 StringBundler query = null;
1556
1557 if (orderByComparator != null) {
1558 query = new StringBundler(3 +
1559 (orderByComparator.getOrderByFields().length * 3));
1560 }
1561 else {
1562 query = new StringBundler(3);
1563 }
1564
1565 query.append(_SQL_SELECT_JOURNALFEED_WHERE);
1566
1567 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1568
1569 if (orderByComparator != null) {
1570 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1571 orderByComparator);
1572 }
1573 else
1574 if (pagination) {
1575 query.append(JournalFeedModelImpl.ORDER_BY_JPQL);
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(groupId);
1590
1591 if (!pagination) {
1592 list = (List<JournalFeed>)QueryUtil.list(q, getDialect(),
1593 start, end, false);
1594
1595 Collections.sort(list);
1596
1597 list = new UnmodifiableList<JournalFeed>(list);
1598 }
1599 else {
1600 list = (List<JournalFeed>)QueryUtil.list(q, getDialect(),
1601 start, end);
1602 }
1603
1604 cacheResult(list);
1605
1606 FinderCacheUtil.putResult(finderPath, finderArgs, list);
1607 }
1608 catch (Exception e) {
1609 FinderCacheUtil.removeResult(finderPath, finderArgs);
1610
1611 throw processException(e);
1612 }
1613 finally {
1614 closeSession(session);
1615 }
1616 }
1617
1618 return list;
1619 }
1620
1621
1630 @Override
1631 public JournalFeed findByGroupId_First(long groupId,
1632 OrderByComparator orderByComparator)
1633 throws NoSuchFeedException, SystemException {
1634 JournalFeed journalFeed = fetchByGroupId_First(groupId,
1635 orderByComparator);
1636
1637 if (journalFeed != null) {
1638 return journalFeed;
1639 }
1640
1641 StringBundler msg = new StringBundler(4);
1642
1643 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1644
1645 msg.append("groupId=");
1646 msg.append(groupId);
1647
1648 msg.append(StringPool.CLOSE_CURLY_BRACE);
1649
1650 throw new NoSuchFeedException(msg.toString());
1651 }
1652
1653
1661 @Override
1662 public JournalFeed fetchByGroupId_First(long groupId,
1663 OrderByComparator orderByComparator) throws SystemException {
1664 List<JournalFeed> list = findByGroupId(groupId, 0, 1, orderByComparator);
1665
1666 if (!list.isEmpty()) {
1667 return list.get(0);
1668 }
1669
1670 return null;
1671 }
1672
1673
1682 @Override
1683 public JournalFeed findByGroupId_Last(long groupId,
1684 OrderByComparator orderByComparator)
1685 throws NoSuchFeedException, SystemException {
1686 JournalFeed journalFeed = fetchByGroupId_Last(groupId, orderByComparator);
1687
1688 if (journalFeed != null) {
1689 return journalFeed;
1690 }
1691
1692 StringBundler msg = new StringBundler(4);
1693
1694 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1695
1696 msg.append("groupId=");
1697 msg.append(groupId);
1698
1699 msg.append(StringPool.CLOSE_CURLY_BRACE);
1700
1701 throw new NoSuchFeedException(msg.toString());
1702 }
1703
1704
1712 @Override
1713 public JournalFeed fetchByGroupId_Last(long groupId,
1714 OrderByComparator orderByComparator) throws SystemException {
1715 int count = countByGroupId(groupId);
1716
1717 if (count == 0) {
1718 return null;
1719 }
1720
1721 List<JournalFeed> list = findByGroupId(groupId, count - 1, count,
1722 orderByComparator);
1723
1724 if (!list.isEmpty()) {
1725 return list.get(0);
1726 }
1727
1728 return null;
1729 }
1730
1731
1741 @Override
1742 public JournalFeed[] findByGroupId_PrevAndNext(long id, long groupId,
1743 OrderByComparator orderByComparator)
1744 throws NoSuchFeedException, SystemException {
1745 JournalFeed journalFeed = findByPrimaryKey(id);
1746
1747 Session session = null;
1748
1749 try {
1750 session = openSession();
1751
1752 JournalFeed[] array = new JournalFeedImpl[3];
1753
1754 array[0] = getByGroupId_PrevAndNext(session, journalFeed, groupId,
1755 orderByComparator, true);
1756
1757 array[1] = journalFeed;
1758
1759 array[2] = getByGroupId_PrevAndNext(session, journalFeed, groupId,
1760 orderByComparator, false);
1761
1762 return array;
1763 }
1764 catch (Exception e) {
1765 throw processException(e);
1766 }
1767 finally {
1768 closeSession(session);
1769 }
1770 }
1771
1772 protected JournalFeed getByGroupId_PrevAndNext(Session session,
1773 JournalFeed journalFeed, long groupId,
1774 OrderByComparator orderByComparator, boolean previous) {
1775 StringBundler query = null;
1776
1777 if (orderByComparator != null) {
1778 query = new StringBundler(6 +
1779 (orderByComparator.getOrderByFields().length * 6));
1780 }
1781 else {
1782 query = new StringBundler(3);
1783 }
1784
1785 query.append(_SQL_SELECT_JOURNALFEED_WHERE);
1786
1787 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1788
1789 if (orderByComparator != null) {
1790 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
1791
1792 if (orderByConditionFields.length > 0) {
1793 query.append(WHERE_AND);
1794 }
1795
1796 for (int i = 0; i < orderByConditionFields.length; i++) {
1797 query.append(_ORDER_BY_ENTITY_ALIAS);
1798 query.append(orderByConditionFields[i]);
1799
1800 if ((i + 1) < orderByConditionFields.length) {
1801 if (orderByComparator.isAscending() ^ previous) {
1802 query.append(WHERE_GREATER_THAN_HAS_NEXT);
1803 }
1804 else {
1805 query.append(WHERE_LESSER_THAN_HAS_NEXT);
1806 }
1807 }
1808 else {
1809 if (orderByComparator.isAscending() ^ previous) {
1810 query.append(WHERE_GREATER_THAN);
1811 }
1812 else {
1813 query.append(WHERE_LESSER_THAN);
1814 }
1815 }
1816 }
1817
1818 query.append(ORDER_BY_CLAUSE);
1819
1820 String[] orderByFields = orderByComparator.getOrderByFields();
1821
1822 for (int i = 0; i < orderByFields.length; i++) {
1823 query.append(_ORDER_BY_ENTITY_ALIAS);
1824 query.append(orderByFields[i]);
1825
1826 if ((i + 1) < orderByFields.length) {
1827 if (orderByComparator.isAscending() ^ previous) {
1828 query.append(ORDER_BY_ASC_HAS_NEXT);
1829 }
1830 else {
1831 query.append(ORDER_BY_DESC_HAS_NEXT);
1832 }
1833 }
1834 else {
1835 if (orderByComparator.isAscending() ^ previous) {
1836 query.append(ORDER_BY_ASC);
1837 }
1838 else {
1839 query.append(ORDER_BY_DESC);
1840 }
1841 }
1842 }
1843 }
1844 else {
1845 query.append(JournalFeedModelImpl.ORDER_BY_JPQL);
1846 }
1847
1848 String sql = query.toString();
1849
1850 Query q = session.createQuery(sql);
1851
1852 q.setFirstResult(0);
1853 q.setMaxResults(2);
1854
1855 QueryPos qPos = QueryPos.getInstance(q);
1856
1857 qPos.add(groupId);
1858
1859 if (orderByComparator != null) {
1860 Object[] values = orderByComparator.getOrderByConditionValues(journalFeed);
1861
1862 for (Object value : values) {
1863 qPos.add(value);
1864 }
1865 }
1866
1867 List<JournalFeed> list = q.list();
1868
1869 if (list.size() == 2) {
1870 return list.get(1);
1871 }
1872 else {
1873 return null;
1874 }
1875 }
1876
1877
1884 @Override
1885 public List<JournalFeed> filterFindByGroupId(long groupId)
1886 throws SystemException {
1887 return filterFindByGroupId(groupId, QueryUtil.ALL_POS,
1888 QueryUtil.ALL_POS, null);
1889 }
1890
1891
1904 @Override
1905 public List<JournalFeed> filterFindByGroupId(long groupId, int start,
1906 int end) throws SystemException {
1907 return filterFindByGroupId(groupId, start, end, null);
1908 }
1909
1910
1924 @Override
1925 public List<JournalFeed> filterFindByGroupId(long groupId, int start,
1926 int end, OrderByComparator orderByComparator) throws SystemException {
1927 if (!InlineSQLHelperUtil.isEnabled(groupId)) {
1928 return findByGroupId(groupId, start, end, orderByComparator);
1929 }
1930
1931 StringBundler query = null;
1932
1933 if (orderByComparator != null) {
1934 query = new StringBundler(3 +
1935 (orderByComparator.getOrderByFields().length * 3));
1936 }
1937 else {
1938 query = new StringBundler(3);
1939 }
1940
1941 if (getDB().isSupportsInlineDistinct()) {
1942 query.append(_FILTER_SQL_SELECT_JOURNALFEED_WHERE);
1943 }
1944 else {
1945 query.append(_FILTER_SQL_SELECT_JOURNALFEED_NO_INLINE_DISTINCT_WHERE_1);
1946 }
1947
1948 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1949
1950 if (!getDB().isSupportsInlineDistinct()) {
1951 query.append(_FILTER_SQL_SELECT_JOURNALFEED_NO_INLINE_DISTINCT_WHERE_2);
1952 }
1953
1954 if (orderByComparator != null) {
1955 if (getDB().isSupportsInlineDistinct()) {
1956 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1957 orderByComparator, true);
1958 }
1959 else {
1960 appendOrderByComparator(query, _ORDER_BY_ENTITY_TABLE,
1961 orderByComparator, true);
1962 }
1963 }
1964 else {
1965 if (getDB().isSupportsInlineDistinct()) {
1966 query.append(JournalFeedModelImpl.ORDER_BY_JPQL);
1967 }
1968 else {
1969 query.append(JournalFeedModelImpl.ORDER_BY_SQL);
1970 }
1971 }
1972
1973 String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
1974 JournalFeed.class.getName(),
1975 _FILTER_ENTITY_TABLE_FILTER_PK_COLUMN, groupId);
1976
1977 Session session = null;
1978
1979 try {
1980 session = openSession();
1981
1982 SQLQuery q = session.createSQLQuery(sql);
1983
1984 if (getDB().isSupportsInlineDistinct()) {
1985 q.addEntity(_FILTER_ENTITY_ALIAS, JournalFeedImpl.class);
1986 }
1987 else {
1988 q.addEntity(_FILTER_ENTITY_TABLE, JournalFeedImpl.class);
1989 }
1990
1991 QueryPos qPos = QueryPos.getInstance(q);
1992
1993 qPos.add(groupId);
1994
1995 return (List<JournalFeed>)QueryUtil.list(q, getDialect(), start, end);
1996 }
1997 catch (Exception e) {
1998 throw processException(e);
1999 }
2000 finally {
2001 closeSession(session);
2002 }
2003 }
2004
2005
2015 @Override
2016 public JournalFeed[] filterFindByGroupId_PrevAndNext(long id, long groupId,
2017 OrderByComparator orderByComparator)
2018 throws NoSuchFeedException, SystemException {
2019 if (!InlineSQLHelperUtil.isEnabled(groupId)) {
2020 return findByGroupId_PrevAndNext(id, groupId, orderByComparator);
2021 }
2022
2023 JournalFeed journalFeed = findByPrimaryKey(id);
2024
2025 Session session = null;
2026
2027 try {
2028 session = openSession();
2029
2030 JournalFeed[] array = new JournalFeedImpl[3];
2031
2032 array[0] = filterGetByGroupId_PrevAndNext(session, journalFeed,
2033 groupId, orderByComparator, true);
2034
2035 array[1] = journalFeed;
2036
2037 array[2] = filterGetByGroupId_PrevAndNext(session, journalFeed,
2038 groupId, orderByComparator, false);
2039
2040 return array;
2041 }
2042 catch (Exception e) {
2043 throw processException(e);
2044 }
2045 finally {
2046 closeSession(session);
2047 }
2048 }
2049
2050 protected JournalFeed filterGetByGroupId_PrevAndNext(Session session,
2051 JournalFeed journalFeed, long groupId,
2052 OrderByComparator orderByComparator, boolean previous) {
2053 StringBundler query = null;
2054
2055 if (orderByComparator != null) {
2056 query = new StringBundler(6 +
2057 (orderByComparator.getOrderByFields().length * 6));
2058 }
2059 else {
2060 query = new StringBundler(3);
2061 }
2062
2063 if (getDB().isSupportsInlineDistinct()) {
2064 query.append(_FILTER_SQL_SELECT_JOURNALFEED_WHERE);
2065 }
2066 else {
2067 query.append(_FILTER_SQL_SELECT_JOURNALFEED_NO_INLINE_DISTINCT_WHERE_1);
2068 }
2069
2070 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
2071
2072 if (!getDB().isSupportsInlineDistinct()) {
2073 query.append(_FILTER_SQL_SELECT_JOURNALFEED_NO_INLINE_DISTINCT_WHERE_2);
2074 }
2075
2076 if (orderByComparator != null) {
2077 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
2078
2079 if (orderByConditionFields.length > 0) {
2080 query.append(WHERE_AND);
2081 }
2082
2083 for (int i = 0; i < orderByConditionFields.length; i++) {
2084 if (getDB().isSupportsInlineDistinct()) {
2085 query.append(_ORDER_BY_ENTITY_ALIAS);
2086 }
2087 else {
2088 query.append(_ORDER_BY_ENTITY_TABLE);
2089 }
2090
2091 query.append(orderByConditionFields[i]);
2092
2093 if ((i + 1) < orderByConditionFields.length) {
2094 if (orderByComparator.isAscending() ^ previous) {
2095 query.append(WHERE_GREATER_THAN_HAS_NEXT);
2096 }
2097 else {
2098 query.append(WHERE_LESSER_THAN_HAS_NEXT);
2099 }
2100 }
2101 else {
2102 if (orderByComparator.isAscending() ^ previous) {
2103 query.append(WHERE_GREATER_THAN);
2104 }
2105 else {
2106 query.append(WHERE_LESSER_THAN);
2107 }
2108 }
2109 }
2110
2111 query.append(ORDER_BY_CLAUSE);
2112
2113 String[] orderByFields = orderByComparator.getOrderByFields();
2114
2115 for (int i = 0; i < orderByFields.length; i++) {
2116 if (getDB().isSupportsInlineDistinct()) {
2117 query.append(_ORDER_BY_ENTITY_ALIAS);
2118 }
2119 else {
2120 query.append(_ORDER_BY_ENTITY_TABLE);
2121 }
2122
2123 query.append(orderByFields[i]);
2124
2125 if ((i + 1) < orderByFields.length) {
2126 if (orderByComparator.isAscending() ^ previous) {
2127 query.append(ORDER_BY_ASC_HAS_NEXT);
2128 }
2129 else {
2130 query.append(ORDER_BY_DESC_HAS_NEXT);
2131 }
2132 }
2133 else {
2134 if (orderByComparator.isAscending() ^ previous) {
2135 query.append(ORDER_BY_ASC);
2136 }
2137 else {
2138 query.append(ORDER_BY_DESC);
2139 }
2140 }
2141 }
2142 }
2143 else {
2144 if (getDB().isSupportsInlineDistinct()) {
2145 query.append(JournalFeedModelImpl.ORDER_BY_JPQL);
2146 }
2147 else {
2148 query.append(JournalFeedModelImpl.ORDER_BY_SQL);
2149 }
2150 }
2151
2152 String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
2153 JournalFeed.class.getName(),
2154 _FILTER_ENTITY_TABLE_FILTER_PK_COLUMN, groupId);
2155
2156 SQLQuery q = session.createSQLQuery(sql);
2157
2158 q.setFirstResult(0);
2159 q.setMaxResults(2);
2160
2161 if (getDB().isSupportsInlineDistinct()) {
2162 q.addEntity(_FILTER_ENTITY_ALIAS, JournalFeedImpl.class);
2163 }
2164 else {
2165 q.addEntity(_FILTER_ENTITY_TABLE, JournalFeedImpl.class);
2166 }
2167
2168 QueryPos qPos = QueryPos.getInstance(q);
2169
2170 qPos.add(groupId);
2171
2172 if (orderByComparator != null) {
2173 Object[] values = orderByComparator.getOrderByConditionValues(journalFeed);
2174
2175 for (Object value : values) {
2176 qPos.add(value);
2177 }
2178 }
2179
2180 List<JournalFeed> list = q.list();
2181
2182 if (list.size() == 2) {
2183 return list.get(1);
2184 }
2185 else {
2186 return null;
2187 }
2188 }
2189
2190
2196 @Override
2197 public void removeByGroupId(long groupId) throws SystemException {
2198 for (JournalFeed journalFeed : findByGroupId(groupId,
2199 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
2200 remove(journalFeed);
2201 }
2202 }
2203
2204
2211 @Override
2212 public int countByGroupId(long groupId) throws SystemException {
2213 FinderPath finderPath = FINDER_PATH_COUNT_BY_GROUPID;
2214
2215 Object[] finderArgs = new Object[] { groupId };
2216
2217 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
2218 this);
2219
2220 if (count == null) {
2221 StringBundler query = new StringBundler(2);
2222
2223 query.append(_SQL_COUNT_JOURNALFEED_WHERE);
2224
2225 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
2226
2227 String sql = query.toString();
2228
2229 Session session = null;
2230
2231 try {
2232 session = openSession();
2233
2234 Query q = session.createQuery(sql);
2235
2236 QueryPos qPos = QueryPos.getInstance(q);
2237
2238 qPos.add(groupId);
2239
2240 count = (Long)q.uniqueResult();
2241
2242 FinderCacheUtil.putResult(finderPath, finderArgs, count);
2243 }
2244 catch (Exception e) {
2245 FinderCacheUtil.removeResult(finderPath, finderArgs);
2246
2247 throw processException(e);
2248 }
2249 finally {
2250 closeSession(session);
2251 }
2252 }
2253
2254 return count.intValue();
2255 }
2256
2257
2264 @Override
2265 public int filterCountByGroupId(long groupId) throws SystemException {
2266 if (!InlineSQLHelperUtil.isEnabled(groupId)) {
2267 return countByGroupId(groupId);
2268 }
2269
2270 StringBundler query = new StringBundler(2);
2271
2272 query.append(_FILTER_SQL_COUNT_JOURNALFEED_WHERE);
2273
2274 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
2275
2276 String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
2277 JournalFeed.class.getName(),
2278 _FILTER_ENTITY_TABLE_FILTER_PK_COLUMN, groupId);
2279
2280 Session session = null;
2281
2282 try {
2283 session = openSession();
2284
2285 SQLQuery q = session.createSQLQuery(sql);
2286
2287 q.addScalar(COUNT_COLUMN_NAME,
2288 com.liferay.portal.kernel.dao.orm.Type.LONG);
2289
2290 QueryPos qPos = QueryPos.getInstance(q);
2291
2292 qPos.add(groupId);
2293
2294 Long count = (Long)q.uniqueResult();
2295
2296 return count.intValue();
2297 }
2298 catch (Exception e) {
2299 throw processException(e);
2300 }
2301 finally {
2302 closeSession(session);
2303 }
2304 }
2305
2306 private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "journalFeed.groupId = ?";
2307 public static final FinderPath FINDER_PATH_FETCH_BY_G_F = new FinderPath(JournalFeedModelImpl.ENTITY_CACHE_ENABLED,
2308 JournalFeedModelImpl.FINDER_CACHE_ENABLED, JournalFeedImpl.class,
2309 FINDER_CLASS_NAME_ENTITY, "fetchByG_F",
2310 new String[] { Long.class.getName(), String.class.getName() },
2311 JournalFeedModelImpl.GROUPID_COLUMN_BITMASK |
2312 JournalFeedModelImpl.FEEDID_COLUMN_BITMASK);
2313 public static final FinderPath FINDER_PATH_COUNT_BY_G_F = new FinderPath(JournalFeedModelImpl.ENTITY_CACHE_ENABLED,
2314 JournalFeedModelImpl.FINDER_CACHE_ENABLED, Long.class,
2315 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByG_F",
2316 new String[] { Long.class.getName(), String.class.getName() });
2317
2318
2327 @Override
2328 public JournalFeed findByG_F(long groupId, String feedId)
2329 throws NoSuchFeedException, SystemException {
2330 JournalFeed journalFeed = fetchByG_F(groupId, feedId);
2331
2332 if (journalFeed == null) {
2333 StringBundler msg = new StringBundler(6);
2334
2335 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2336
2337 msg.append("groupId=");
2338 msg.append(groupId);
2339
2340 msg.append(", feedId=");
2341 msg.append(feedId);
2342
2343 msg.append(StringPool.CLOSE_CURLY_BRACE);
2344
2345 if (_log.isWarnEnabled()) {
2346 _log.warn(msg.toString());
2347 }
2348
2349 throw new NoSuchFeedException(msg.toString());
2350 }
2351
2352 return journalFeed;
2353 }
2354
2355
2363 @Override
2364 public JournalFeed fetchByG_F(long groupId, String feedId)
2365 throws SystemException {
2366 return fetchByG_F(groupId, feedId, true);
2367 }
2368
2369
2378 @Override
2379 public JournalFeed fetchByG_F(long groupId, String feedId,
2380 boolean retrieveFromCache) throws SystemException {
2381 Object[] finderArgs = new Object[] { groupId, feedId };
2382
2383 Object result = null;
2384
2385 if (retrieveFromCache) {
2386 result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_G_F,
2387 finderArgs, this);
2388 }
2389
2390 if (result instanceof JournalFeed) {
2391 JournalFeed journalFeed = (JournalFeed)result;
2392
2393 if ((groupId != journalFeed.getGroupId()) ||
2394 !Validator.equals(feedId, journalFeed.getFeedId())) {
2395 result = null;
2396 }
2397 }
2398
2399 if (result == null) {
2400 StringBundler query = new StringBundler(4);
2401
2402 query.append(_SQL_SELECT_JOURNALFEED_WHERE);
2403
2404 query.append(_FINDER_COLUMN_G_F_GROUPID_2);
2405
2406 boolean bindFeedId = false;
2407
2408 if (feedId == null) {
2409 query.append(_FINDER_COLUMN_G_F_FEEDID_1);
2410 }
2411 else if (feedId.equals(StringPool.BLANK)) {
2412 query.append(_FINDER_COLUMN_G_F_FEEDID_3);
2413 }
2414 else {
2415 bindFeedId = true;
2416
2417 query.append(_FINDER_COLUMN_G_F_FEEDID_2);
2418 }
2419
2420 String sql = query.toString();
2421
2422 Session session = null;
2423
2424 try {
2425 session = openSession();
2426
2427 Query q = session.createQuery(sql);
2428
2429 QueryPos qPos = QueryPos.getInstance(q);
2430
2431 qPos.add(groupId);
2432
2433 if (bindFeedId) {
2434 qPos.add(feedId);
2435 }
2436
2437 List<JournalFeed> list = q.list();
2438
2439 if (list.isEmpty()) {
2440 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_F,
2441 finderArgs, list);
2442 }
2443 else {
2444 JournalFeed journalFeed = list.get(0);
2445
2446 result = journalFeed;
2447
2448 cacheResult(journalFeed);
2449
2450 if ((journalFeed.getGroupId() != groupId) ||
2451 (journalFeed.getFeedId() == null) ||
2452 !journalFeed.getFeedId().equals(feedId)) {
2453 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_F,
2454 finderArgs, journalFeed);
2455 }
2456 }
2457 }
2458 catch (Exception e) {
2459 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_F,
2460 finderArgs);
2461
2462 throw processException(e);
2463 }
2464 finally {
2465 closeSession(session);
2466 }
2467 }
2468
2469 if (result instanceof List<?>) {
2470 return null;
2471 }
2472 else {
2473 return (JournalFeed)result;
2474 }
2475 }
2476
2477
2485 @Override
2486 public JournalFeed removeByG_F(long groupId, String feedId)
2487 throws NoSuchFeedException, SystemException {
2488 JournalFeed journalFeed = findByG_F(groupId, feedId);
2489
2490 return remove(journalFeed);
2491 }
2492
2493
2501 @Override
2502 public int countByG_F(long groupId, String feedId)
2503 throws SystemException {
2504 FinderPath finderPath = FINDER_PATH_COUNT_BY_G_F;
2505
2506 Object[] finderArgs = new Object[] { groupId, feedId };
2507
2508 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
2509 this);
2510
2511 if (count == null) {
2512 StringBundler query = new StringBundler(3);
2513
2514 query.append(_SQL_COUNT_JOURNALFEED_WHERE);
2515
2516 query.append(_FINDER_COLUMN_G_F_GROUPID_2);
2517
2518 boolean bindFeedId = false;
2519
2520 if (feedId == null) {
2521 query.append(_FINDER_COLUMN_G_F_FEEDID_1);
2522 }
2523 else if (feedId.equals(StringPool.BLANK)) {
2524 query.append(_FINDER_COLUMN_G_F_FEEDID_3);
2525 }
2526 else {
2527 bindFeedId = true;
2528
2529 query.append(_FINDER_COLUMN_G_F_FEEDID_2);
2530 }
2531
2532 String sql = query.toString();
2533
2534 Session session = null;
2535
2536 try {
2537 session = openSession();
2538
2539 Query q = session.createQuery(sql);
2540
2541 QueryPos qPos = QueryPos.getInstance(q);
2542
2543 qPos.add(groupId);
2544
2545 if (bindFeedId) {
2546 qPos.add(feedId);
2547 }
2548
2549 count = (Long)q.uniqueResult();
2550
2551 FinderCacheUtil.putResult(finderPath, finderArgs, count);
2552 }
2553 catch (Exception e) {
2554 FinderCacheUtil.removeResult(finderPath, finderArgs);
2555
2556 throw processException(e);
2557 }
2558 finally {
2559 closeSession(session);
2560 }
2561 }
2562
2563 return count.intValue();
2564 }
2565
2566 private static final String _FINDER_COLUMN_G_F_GROUPID_2 = "journalFeed.groupId = ? AND ";
2567 private static final String _FINDER_COLUMN_G_F_FEEDID_1 = "journalFeed.feedId IS NULL";
2568 private static final String _FINDER_COLUMN_G_F_FEEDID_2 = "journalFeed.feedId = ?";
2569 private static final String _FINDER_COLUMN_G_F_FEEDID_3 = "(journalFeed.feedId IS NULL OR journalFeed.feedId = '')";
2570
2571 public JournalFeedPersistenceImpl() {
2572 setModelClass(JournalFeed.class);
2573 }
2574
2575
2580 @Override
2581 public void cacheResult(JournalFeed journalFeed) {
2582 EntityCacheUtil.putResult(JournalFeedModelImpl.ENTITY_CACHE_ENABLED,
2583 JournalFeedImpl.class, journalFeed.getPrimaryKey(), journalFeed);
2584
2585 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
2586 new Object[] { journalFeed.getUuid(), journalFeed.getGroupId() },
2587 journalFeed);
2588
2589 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_F,
2590 new Object[] { journalFeed.getGroupId(), journalFeed.getFeedId() },
2591 journalFeed);
2592
2593 journalFeed.resetOriginalValues();
2594 }
2595
2596
2601 @Override
2602 public void cacheResult(List<JournalFeed> journalFeeds) {
2603 for (JournalFeed journalFeed : journalFeeds) {
2604 if (EntityCacheUtil.getResult(
2605 JournalFeedModelImpl.ENTITY_CACHE_ENABLED,
2606 JournalFeedImpl.class, journalFeed.getPrimaryKey()) == null) {
2607 cacheResult(journalFeed);
2608 }
2609 else {
2610 journalFeed.resetOriginalValues();
2611 }
2612 }
2613 }
2614
2615
2622 @Override
2623 public void clearCache() {
2624 if (_HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE) {
2625 CacheRegistryUtil.clear(JournalFeedImpl.class.getName());
2626 }
2627
2628 EntityCacheUtil.clearCache(JournalFeedImpl.class.getName());
2629
2630 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
2631 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
2632 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
2633 }
2634
2635
2642 @Override
2643 public void clearCache(JournalFeed journalFeed) {
2644 EntityCacheUtil.removeResult(JournalFeedModelImpl.ENTITY_CACHE_ENABLED,
2645 JournalFeedImpl.class, journalFeed.getPrimaryKey());
2646
2647 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
2648 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
2649
2650 clearUniqueFindersCache(journalFeed);
2651 }
2652
2653 @Override
2654 public void clearCache(List<JournalFeed> journalFeeds) {
2655 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
2656 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
2657
2658 for (JournalFeed journalFeed : journalFeeds) {
2659 EntityCacheUtil.removeResult(JournalFeedModelImpl.ENTITY_CACHE_ENABLED,
2660 JournalFeedImpl.class, journalFeed.getPrimaryKey());
2661
2662 clearUniqueFindersCache(journalFeed);
2663 }
2664 }
2665
2666 protected void cacheUniqueFindersCache(JournalFeed journalFeed) {
2667 if (journalFeed.isNew()) {
2668 Object[] args = new Object[] {
2669 journalFeed.getUuid(), journalFeed.getGroupId()
2670 };
2671
2672 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID_G, args,
2673 Long.valueOf(1));
2674 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G, args,
2675 journalFeed);
2676
2677 args = new Object[] {
2678 journalFeed.getGroupId(), journalFeed.getFeedId()
2679 };
2680
2681 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_F, args,
2682 Long.valueOf(1));
2683 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_F, args,
2684 journalFeed);
2685 }
2686 else {
2687 JournalFeedModelImpl journalFeedModelImpl = (JournalFeedModelImpl)journalFeed;
2688
2689 if ((journalFeedModelImpl.getColumnBitmask() &
2690 FINDER_PATH_FETCH_BY_UUID_G.getColumnBitmask()) != 0) {
2691 Object[] args = new Object[] {
2692 journalFeed.getUuid(), journalFeed.getGroupId()
2693 };
2694
2695 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID_G, args,
2696 Long.valueOf(1));
2697 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G, args,
2698 journalFeed);
2699 }
2700
2701 if ((journalFeedModelImpl.getColumnBitmask() &
2702 FINDER_PATH_FETCH_BY_G_F.getColumnBitmask()) != 0) {
2703 Object[] args = new Object[] {
2704 journalFeed.getGroupId(), journalFeed.getFeedId()
2705 };
2706
2707 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_F, args,
2708 Long.valueOf(1));
2709 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_F, args,
2710 journalFeed);
2711 }
2712 }
2713 }
2714
2715 protected void clearUniqueFindersCache(JournalFeed journalFeed) {
2716 JournalFeedModelImpl journalFeedModelImpl = (JournalFeedModelImpl)journalFeed;
2717
2718 Object[] args = new Object[] {
2719 journalFeed.getUuid(), journalFeed.getGroupId()
2720 };
2721
2722 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID_G, args);
2723 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G, args);
2724
2725 if ((journalFeedModelImpl.getColumnBitmask() &
2726 FINDER_PATH_FETCH_BY_UUID_G.getColumnBitmask()) != 0) {
2727 args = new Object[] {
2728 journalFeedModelImpl.getOriginalUuid(),
2729 journalFeedModelImpl.getOriginalGroupId()
2730 };
2731
2732 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID_G, args);
2733 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G, args);
2734 }
2735
2736 args = new Object[] { journalFeed.getGroupId(), journalFeed.getFeedId() };
2737
2738 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_G_F, args);
2739 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_F, args);
2740
2741 if ((journalFeedModelImpl.getColumnBitmask() &
2742 FINDER_PATH_FETCH_BY_G_F.getColumnBitmask()) != 0) {
2743 args = new Object[] {
2744 journalFeedModelImpl.getOriginalGroupId(),
2745 journalFeedModelImpl.getOriginalFeedId()
2746 };
2747
2748 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_G_F, args);
2749 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_F, args);
2750 }
2751 }
2752
2753
2759 @Override
2760 public JournalFeed create(long id) {
2761 JournalFeed journalFeed = new JournalFeedImpl();
2762
2763 journalFeed.setNew(true);
2764 journalFeed.setPrimaryKey(id);
2765
2766 String uuid = PortalUUIDUtil.generate();
2767
2768 journalFeed.setUuid(uuid);
2769
2770 return journalFeed;
2771 }
2772
2773
2781 @Override
2782 public JournalFeed remove(long id)
2783 throws NoSuchFeedException, SystemException {
2784 return remove((Serializable)id);
2785 }
2786
2787
2795 @Override
2796 public JournalFeed remove(Serializable primaryKey)
2797 throws NoSuchFeedException, SystemException {
2798 Session session = null;
2799
2800 try {
2801 session = openSession();
2802
2803 JournalFeed journalFeed = (JournalFeed)session.get(JournalFeedImpl.class,
2804 primaryKey);
2805
2806 if (journalFeed == null) {
2807 if (_log.isWarnEnabled()) {
2808 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey);
2809 }
2810
2811 throw new NoSuchFeedException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
2812 primaryKey);
2813 }
2814
2815 return remove(journalFeed);
2816 }
2817 catch (NoSuchFeedException nsee) {
2818 throw nsee;
2819 }
2820 catch (Exception e) {
2821 throw processException(e);
2822 }
2823 finally {
2824 closeSession(session);
2825 }
2826 }
2827
2828 @Override
2829 protected JournalFeed removeImpl(JournalFeed journalFeed)
2830 throws SystemException {
2831 journalFeed = toUnwrappedModel(journalFeed);
2832
2833 Session session = null;
2834
2835 try {
2836 session = openSession();
2837
2838 if (!session.contains(journalFeed)) {
2839 journalFeed = (JournalFeed)session.get(JournalFeedImpl.class,
2840 journalFeed.getPrimaryKeyObj());
2841 }
2842
2843 if (journalFeed != null) {
2844 session.delete(journalFeed);
2845 }
2846 }
2847 catch (Exception e) {
2848 throw processException(e);
2849 }
2850 finally {
2851 closeSession(session);
2852 }
2853
2854 if (journalFeed != null) {
2855 clearCache(journalFeed);
2856 }
2857
2858 return journalFeed;
2859 }
2860
2861 @Override
2862 public JournalFeed updateImpl(
2863 com.liferay.portlet.journal.model.JournalFeed journalFeed)
2864 throws SystemException {
2865 journalFeed = toUnwrappedModel(journalFeed);
2866
2867 boolean isNew = journalFeed.isNew();
2868
2869 JournalFeedModelImpl journalFeedModelImpl = (JournalFeedModelImpl)journalFeed;
2870
2871 if (Validator.isNull(journalFeed.getUuid())) {
2872 String uuid = PortalUUIDUtil.generate();
2873
2874 journalFeed.setUuid(uuid);
2875 }
2876
2877 Session session = null;
2878
2879 try {
2880 session = openSession();
2881
2882 if (journalFeed.isNew()) {
2883 session.save(journalFeed);
2884
2885 journalFeed.setNew(false);
2886 }
2887 else {
2888 session.merge(journalFeed);
2889 }
2890 }
2891 catch (Exception e) {
2892 throw processException(e);
2893 }
2894 finally {
2895 closeSession(session);
2896 }
2897
2898 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
2899
2900 if (isNew || !JournalFeedModelImpl.COLUMN_BITMASK_ENABLED) {
2901 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
2902 }
2903
2904 else {
2905 if ((journalFeedModelImpl.getColumnBitmask() &
2906 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID.getColumnBitmask()) != 0) {
2907 Object[] args = new Object[] {
2908 journalFeedModelImpl.getOriginalUuid()
2909 };
2910
2911 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID, args);
2912 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID,
2913 args);
2914
2915 args = new Object[] { journalFeedModelImpl.getUuid() };
2916
2917 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID, args);
2918 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID,
2919 args);
2920 }
2921
2922 if ((journalFeedModelImpl.getColumnBitmask() &
2923 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C.getColumnBitmask()) != 0) {
2924 Object[] args = new Object[] {
2925 journalFeedModelImpl.getOriginalUuid(),
2926 journalFeedModelImpl.getOriginalCompanyId()
2927 };
2928
2929 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID_C, args);
2930 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C,
2931 args);
2932
2933 args = new Object[] {
2934 journalFeedModelImpl.getUuid(),
2935 journalFeedModelImpl.getCompanyId()
2936 };
2937
2938 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID_C, args);
2939 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C,
2940 args);
2941 }
2942
2943 if ((journalFeedModelImpl.getColumnBitmask() &
2944 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID.getColumnBitmask()) != 0) {
2945 Object[] args = new Object[] {
2946 journalFeedModelImpl.getOriginalGroupId()
2947 };
2948
2949 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_GROUPID, args);
2950 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID,
2951 args);
2952
2953 args = new Object[] { journalFeedModelImpl.getGroupId() };
2954
2955 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_GROUPID, args);
2956 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID,
2957 args);
2958 }
2959 }
2960
2961 EntityCacheUtil.putResult(JournalFeedModelImpl.ENTITY_CACHE_ENABLED,
2962 JournalFeedImpl.class, journalFeed.getPrimaryKey(), journalFeed);
2963
2964 clearUniqueFindersCache(journalFeed);
2965 cacheUniqueFindersCache(journalFeed);
2966
2967 return journalFeed;
2968 }
2969
2970 protected JournalFeed toUnwrappedModel(JournalFeed journalFeed) {
2971 if (journalFeed instanceof JournalFeedImpl) {
2972 return journalFeed;
2973 }
2974
2975 JournalFeedImpl journalFeedImpl = new JournalFeedImpl();
2976
2977 journalFeedImpl.setNew(journalFeed.isNew());
2978 journalFeedImpl.setPrimaryKey(journalFeed.getPrimaryKey());
2979
2980 journalFeedImpl.setUuid(journalFeed.getUuid());
2981 journalFeedImpl.setId(journalFeed.getId());
2982 journalFeedImpl.setGroupId(journalFeed.getGroupId());
2983 journalFeedImpl.setCompanyId(journalFeed.getCompanyId());
2984 journalFeedImpl.setUserId(journalFeed.getUserId());
2985 journalFeedImpl.setUserName(journalFeed.getUserName());
2986 journalFeedImpl.setCreateDate(journalFeed.getCreateDate());
2987 journalFeedImpl.setModifiedDate(journalFeed.getModifiedDate());
2988 journalFeedImpl.setFeedId(journalFeed.getFeedId());
2989 journalFeedImpl.setName(journalFeed.getName());
2990 journalFeedImpl.setDescription(journalFeed.getDescription());
2991 journalFeedImpl.setType(journalFeed.getType());
2992 journalFeedImpl.setStructureId(journalFeed.getStructureId());
2993 journalFeedImpl.setTemplateId(journalFeed.getTemplateId());
2994 journalFeedImpl.setRendererTemplateId(journalFeed.getRendererTemplateId());
2995 journalFeedImpl.setDelta(journalFeed.getDelta());
2996 journalFeedImpl.setOrderByCol(journalFeed.getOrderByCol());
2997 journalFeedImpl.setOrderByType(journalFeed.getOrderByType());
2998 journalFeedImpl.setTargetLayoutFriendlyUrl(journalFeed.getTargetLayoutFriendlyUrl());
2999 journalFeedImpl.setTargetPortletId(journalFeed.getTargetPortletId());
3000 journalFeedImpl.setContentField(journalFeed.getContentField());
3001 journalFeedImpl.setFeedFormat(journalFeed.getFeedFormat());
3002 journalFeedImpl.setFeedVersion(journalFeed.getFeedVersion());
3003
3004 return journalFeedImpl;
3005 }
3006
3007
3015 @Override
3016 public JournalFeed findByPrimaryKey(Serializable primaryKey)
3017 throws NoSuchFeedException, SystemException {
3018 JournalFeed journalFeed = fetchByPrimaryKey(primaryKey);
3019
3020 if (journalFeed == null) {
3021 if (_log.isWarnEnabled()) {
3022 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey);
3023 }
3024
3025 throw new NoSuchFeedException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
3026 primaryKey);
3027 }
3028
3029 return journalFeed;
3030 }
3031
3032
3040 @Override
3041 public JournalFeed findByPrimaryKey(long id)
3042 throws NoSuchFeedException, SystemException {
3043 return findByPrimaryKey((Serializable)id);
3044 }
3045
3046
3053 @Override
3054 public JournalFeed fetchByPrimaryKey(Serializable primaryKey)
3055 throws SystemException {
3056 JournalFeed journalFeed = (JournalFeed)EntityCacheUtil.getResult(JournalFeedModelImpl.ENTITY_CACHE_ENABLED,
3057 JournalFeedImpl.class, primaryKey);
3058
3059 if (journalFeed == _nullJournalFeed) {
3060 return null;
3061 }
3062
3063 if (journalFeed == null) {
3064 Session session = null;
3065
3066 try {
3067 session = openSession();
3068
3069 journalFeed = (JournalFeed)session.get(JournalFeedImpl.class,
3070 primaryKey);
3071
3072 if (journalFeed != null) {
3073 cacheResult(journalFeed);
3074 }
3075 else {
3076 EntityCacheUtil.putResult(JournalFeedModelImpl.ENTITY_CACHE_ENABLED,
3077 JournalFeedImpl.class, primaryKey, _nullJournalFeed);
3078 }
3079 }
3080 catch (Exception e) {
3081 EntityCacheUtil.removeResult(JournalFeedModelImpl.ENTITY_CACHE_ENABLED,
3082 JournalFeedImpl.class, primaryKey);
3083
3084 throw processException(e);
3085 }
3086 finally {
3087 closeSession(session);
3088 }
3089 }
3090
3091 return journalFeed;
3092 }
3093
3094
3101 @Override
3102 public JournalFeed fetchByPrimaryKey(long id) throws SystemException {
3103 return fetchByPrimaryKey((Serializable)id);
3104 }
3105
3106
3112 @Override
3113 public List<JournalFeed> findAll() throws SystemException {
3114 return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
3115 }
3116
3117
3129 @Override
3130 public List<JournalFeed> findAll(int start, int end)
3131 throws SystemException {
3132 return findAll(start, end, null);
3133 }
3134
3135
3148 @Override
3149 public List<JournalFeed> findAll(int start, int end,
3150 OrderByComparator orderByComparator) throws SystemException {
3151 boolean pagination = true;
3152 FinderPath finderPath = null;
3153 Object[] finderArgs = null;
3154
3155 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
3156 (orderByComparator == null)) {
3157 pagination = false;
3158 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL;
3159 finderArgs = FINDER_ARGS_EMPTY;
3160 }
3161 else {
3162 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_ALL;
3163 finderArgs = new Object[] { start, end, orderByComparator };
3164 }
3165
3166 List<JournalFeed> list = (List<JournalFeed>)FinderCacheUtil.getResult(finderPath,
3167 finderArgs, this);
3168
3169 if (list == null) {
3170 StringBundler query = null;
3171 String sql = null;
3172
3173 if (orderByComparator != null) {
3174 query = new StringBundler(2 +
3175 (orderByComparator.getOrderByFields().length * 3));
3176
3177 query.append(_SQL_SELECT_JOURNALFEED);
3178
3179 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
3180 orderByComparator);
3181
3182 sql = query.toString();
3183 }
3184 else {
3185 sql = _SQL_SELECT_JOURNALFEED;
3186
3187 if (pagination) {
3188 sql = sql.concat(JournalFeedModelImpl.ORDER_BY_JPQL);
3189 }
3190 }
3191
3192 Session session = null;
3193
3194 try {
3195 session = openSession();
3196
3197 Query q = session.createQuery(sql);
3198
3199 if (!pagination) {
3200 list = (List<JournalFeed>)QueryUtil.list(q, getDialect(),
3201 start, end, false);
3202
3203 Collections.sort(list);
3204
3205 list = new UnmodifiableList<JournalFeed>(list);
3206 }
3207 else {
3208 list = (List<JournalFeed>)QueryUtil.list(q, getDialect(),
3209 start, end);
3210 }
3211
3212 cacheResult(list);
3213
3214 FinderCacheUtil.putResult(finderPath, finderArgs, list);
3215 }
3216 catch (Exception e) {
3217 FinderCacheUtil.removeResult(finderPath, finderArgs);
3218
3219 throw processException(e);
3220 }
3221 finally {
3222 closeSession(session);
3223 }
3224 }
3225
3226 return list;
3227 }
3228
3229
3234 @Override
3235 public void removeAll() throws SystemException {
3236 for (JournalFeed journalFeed : findAll()) {
3237 remove(journalFeed);
3238 }
3239 }
3240
3241
3247 @Override
3248 public int countAll() throws SystemException {
3249 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
3250 FINDER_ARGS_EMPTY, this);
3251
3252 if (count == null) {
3253 Session session = null;
3254
3255 try {
3256 session = openSession();
3257
3258 Query q = session.createQuery(_SQL_COUNT_JOURNALFEED);
3259
3260 count = (Long)q.uniqueResult();
3261
3262 FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL,
3263 FINDER_ARGS_EMPTY, count);
3264 }
3265 catch (Exception e) {
3266 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_ALL,
3267 FINDER_ARGS_EMPTY);
3268
3269 throw processException(e);
3270 }
3271 finally {
3272 closeSession(session);
3273 }
3274 }
3275
3276 return count.intValue();
3277 }
3278
3279 @Override
3280 protected Set<String> getBadColumnNames() {
3281 return _badColumnNames;
3282 }
3283
3284
3287 public void afterPropertiesSet() {
3288 String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
3289 com.liferay.portal.util.PropsUtil.get(
3290 "value.object.listener.com.liferay.portlet.journal.model.JournalFeed")));
3291
3292 if (listenerClassNames.length > 0) {
3293 try {
3294 List<ModelListener<JournalFeed>> listenersList = new ArrayList<ModelListener<JournalFeed>>();
3295
3296 for (String listenerClassName : listenerClassNames) {
3297 listenersList.add((ModelListener<JournalFeed>)InstanceFactory.newInstance(
3298 getClassLoader(), listenerClassName));
3299 }
3300
3301 listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
3302 }
3303 catch (Exception e) {
3304 _log.error(e);
3305 }
3306 }
3307 }
3308
3309 public void destroy() {
3310 EntityCacheUtil.removeCache(JournalFeedImpl.class.getName());
3311 FinderCacheUtil.removeCache(FINDER_CLASS_NAME_ENTITY);
3312 FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
3313 FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
3314 }
3315
3316 private static final String _SQL_SELECT_JOURNALFEED = "SELECT journalFeed FROM JournalFeed journalFeed";
3317 private static final String _SQL_SELECT_JOURNALFEED_WHERE = "SELECT journalFeed FROM JournalFeed journalFeed WHERE ";
3318 private static final String _SQL_COUNT_JOURNALFEED = "SELECT COUNT(journalFeed) FROM JournalFeed journalFeed";
3319 private static final String _SQL_COUNT_JOURNALFEED_WHERE = "SELECT COUNT(journalFeed) FROM JournalFeed journalFeed WHERE ";
3320 private static final String _FILTER_ENTITY_TABLE_FILTER_PK_COLUMN = "journalFeed.id_";
3321 private static final String _FILTER_SQL_SELECT_JOURNALFEED_WHERE = "SELECT DISTINCT {journalFeed.*} FROM JournalFeed journalFeed WHERE ";
3322 private static final String _FILTER_SQL_SELECT_JOURNALFEED_NO_INLINE_DISTINCT_WHERE_1 =
3323 "SELECT {JournalFeed.*} FROM (SELECT DISTINCT journalFeed.id_ FROM JournalFeed journalFeed WHERE ";
3324 private static final String _FILTER_SQL_SELECT_JOURNALFEED_NO_INLINE_DISTINCT_WHERE_2 =
3325 ") TEMP_TABLE INNER JOIN JournalFeed ON TEMP_TABLE.id_ = JournalFeed.id_";
3326 private static final String _FILTER_SQL_COUNT_JOURNALFEED_WHERE = "SELECT COUNT(DISTINCT journalFeed.id_) AS COUNT_VALUE FROM JournalFeed journalFeed WHERE ";
3327 private static final String _FILTER_ENTITY_ALIAS = "journalFeed";
3328 private static final String _FILTER_ENTITY_TABLE = "JournalFeed";
3329 private static final String _ORDER_BY_ENTITY_ALIAS = "journalFeed.";
3330 private static final String _ORDER_BY_ENTITY_TABLE = "JournalFeed.";
3331 private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No JournalFeed exists with the primary key ";
3332 private static final String _NO_SUCH_ENTITY_WITH_KEY = "No JournalFeed exists with the key {";
3333 private static final boolean _HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE = com.liferay.portal.util.PropsValues.HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE;
3334 private static Log _log = LogFactoryUtil.getLog(JournalFeedPersistenceImpl.class);
3335 private static Set<String> _badColumnNames = SetUtil.fromArray(new String[] {
3336 "uuid", "id", "type"
3337 });
3338 private static JournalFeed _nullJournalFeed = new JournalFeedImpl() {
3339 @Override
3340 public Object clone() {
3341 return this;
3342 }
3343
3344 @Override
3345 public CacheModel<JournalFeed> toCacheModel() {
3346 return _nullJournalFeedCacheModel;
3347 }
3348 };
3349
3350 private static CacheModel<JournalFeed> _nullJournalFeedCacheModel = new CacheModel<JournalFeed>() {
3351 @Override
3352 public JournalFeed toEntityModel() {
3353 return _nullJournalFeed;
3354 }
3355 };
3356 }