001
014
015 package com.liferay.portlet.messageboards.service.persistence.impl;
016
017 import aQute.bnd.annotation.ProviderType;
018
019 import com.liferay.portal.kernel.dao.orm.EntityCache;
020 import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
021 import com.liferay.portal.kernel.dao.orm.FinderCache;
022 import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
023 import com.liferay.portal.kernel.dao.orm.FinderPath;
024 import com.liferay.portal.kernel.dao.orm.Query;
025 import com.liferay.portal.kernel.dao.orm.QueryPos;
026 import com.liferay.portal.kernel.dao.orm.QueryUtil;
027 import com.liferay.portal.kernel.dao.orm.Session;
028 import com.liferay.portal.kernel.log.Log;
029 import com.liferay.portal.kernel.log.LogFactoryUtil;
030 import com.liferay.portal.kernel.util.OrderByComparator;
031 import com.liferay.portal.kernel.util.StringBundler;
032 import com.liferay.portal.kernel.util.StringPool;
033 import com.liferay.portal.model.CacheModel;
034 import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
035
036 import com.liferay.portlet.messageboards.NoSuchStatsUserException;
037 import com.liferay.portlet.messageboards.model.MBStatsUser;
038 import com.liferay.portlet.messageboards.model.impl.MBStatsUserImpl;
039 import com.liferay.portlet.messageboards.model.impl.MBStatsUserModelImpl;
040 import com.liferay.portlet.messageboards.service.persistence.MBStatsUserPersistence;
041
042 import java.io.Serializable;
043
044 import java.util.Collections;
045 import java.util.HashMap;
046 import java.util.HashSet;
047 import java.util.Iterator;
048 import java.util.List;
049 import java.util.Map;
050 import java.util.Set;
051
052
064 @ProviderType
065 public class MBStatsUserPersistenceImpl extends BasePersistenceImpl<MBStatsUser>
066 implements MBStatsUserPersistence {
067
072 public static final String FINDER_CLASS_NAME_ENTITY = MBStatsUserImpl.class.getName();
073 public static final String FINDER_CLASS_NAME_LIST_WITH_PAGINATION = FINDER_CLASS_NAME_ENTITY +
074 ".List1";
075 public static final String FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION = FINDER_CLASS_NAME_ENTITY +
076 ".List2";
077 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_ALL = new FinderPath(MBStatsUserModelImpl.ENTITY_CACHE_ENABLED,
078 MBStatsUserModelImpl.FINDER_CACHE_ENABLED, MBStatsUserImpl.class,
079 FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findAll", new String[0]);
080 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL = new FinderPath(MBStatsUserModelImpl.ENTITY_CACHE_ENABLED,
081 MBStatsUserModelImpl.FINDER_CACHE_ENABLED, MBStatsUserImpl.class,
082 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findAll", new String[0]);
083 public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(MBStatsUserModelImpl.ENTITY_CACHE_ENABLED,
084 MBStatsUserModelImpl.FINDER_CACHE_ENABLED, Long.class,
085 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countAll", new String[0]);
086 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_GROUPID = new FinderPath(MBStatsUserModelImpl.ENTITY_CACHE_ENABLED,
087 MBStatsUserModelImpl.FINDER_CACHE_ENABLED, MBStatsUserImpl.class,
088 FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByGroupId",
089 new String[] {
090 Long.class.getName(),
091
092 Integer.class.getName(), Integer.class.getName(),
093 OrderByComparator.class.getName()
094 });
095 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID =
096 new FinderPath(MBStatsUserModelImpl.ENTITY_CACHE_ENABLED,
097 MBStatsUserModelImpl.FINDER_CACHE_ENABLED, MBStatsUserImpl.class,
098 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByGroupId",
099 new String[] { Long.class.getName() },
100 MBStatsUserModelImpl.GROUPID_COLUMN_BITMASK |
101 MBStatsUserModelImpl.MESSAGECOUNT_COLUMN_BITMASK);
102 public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(MBStatsUserModelImpl.ENTITY_CACHE_ENABLED,
103 MBStatsUserModelImpl.FINDER_CACHE_ENABLED, Long.class,
104 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByGroupId",
105 new String[] { Long.class.getName() });
106
107
113 @Override
114 public List<MBStatsUser> findByGroupId(long groupId) {
115 return findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
116 }
117
118
130 @Override
131 public List<MBStatsUser> findByGroupId(long groupId, int start, int end) {
132 return findByGroupId(groupId, start, end, null);
133 }
134
135
148 @Override
149 public List<MBStatsUser> findByGroupId(long groupId, int start, int end,
150 OrderByComparator<MBStatsUser> orderByComparator) {
151 return findByGroupId(groupId, start, end, orderByComparator, true);
152 }
153
154
168 @Override
169 public List<MBStatsUser> findByGroupId(long groupId, int start, int end,
170 OrderByComparator<MBStatsUser> orderByComparator,
171 boolean retrieveFromCache) {
172 boolean pagination = true;
173 FinderPath finderPath = null;
174 Object[] finderArgs = null;
175
176 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
177 (orderByComparator == null)) {
178 pagination = false;
179 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID;
180 finderArgs = new Object[] { groupId };
181 }
182 else {
183 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_GROUPID;
184 finderArgs = new Object[] { groupId, start, end, orderByComparator };
185 }
186
187 List<MBStatsUser> list = null;
188
189 if (retrieveFromCache) {
190 list = (List<MBStatsUser>)finderCache.getResult(finderPath,
191 finderArgs, this);
192
193 if ((list != null) && !list.isEmpty()) {
194 for (MBStatsUser mbStatsUser : list) {
195 if ((groupId != mbStatsUser.getGroupId())) {
196 list = null;
197
198 break;
199 }
200 }
201 }
202 }
203
204 if (list == null) {
205 StringBundler query = null;
206
207 if (orderByComparator != null) {
208 query = new StringBundler(3 +
209 (orderByComparator.getOrderByFields().length * 3));
210 }
211 else {
212 query = new StringBundler(3);
213 }
214
215 query.append(_SQL_SELECT_MBSTATSUSER_WHERE);
216
217 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
218
219 if (orderByComparator != null) {
220 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
221 orderByComparator);
222 }
223 else
224 if (pagination) {
225 query.append(MBStatsUserModelImpl.ORDER_BY_JPQL);
226 }
227
228 String sql = query.toString();
229
230 Session session = null;
231
232 try {
233 session = openSession();
234
235 Query q = session.createQuery(sql);
236
237 QueryPos qPos = QueryPos.getInstance(q);
238
239 qPos.add(groupId);
240
241 if (!pagination) {
242 list = (List<MBStatsUser>)QueryUtil.list(q, getDialect(),
243 start, end, false);
244
245 Collections.sort(list);
246
247 list = Collections.unmodifiableList(list);
248 }
249 else {
250 list = (List<MBStatsUser>)QueryUtil.list(q, getDialect(),
251 start, end);
252 }
253
254 cacheResult(list);
255
256 finderCache.putResult(finderPath, finderArgs, list);
257 }
258 catch (Exception e) {
259 finderCache.removeResult(finderPath, finderArgs);
260
261 throw processException(e);
262 }
263 finally {
264 closeSession(session);
265 }
266 }
267
268 return list;
269 }
270
271
279 @Override
280 public MBStatsUser findByGroupId_First(long groupId,
281 OrderByComparator<MBStatsUser> orderByComparator)
282 throws NoSuchStatsUserException {
283 MBStatsUser mbStatsUser = fetchByGroupId_First(groupId,
284 orderByComparator);
285
286 if (mbStatsUser != null) {
287 return mbStatsUser;
288 }
289
290 StringBundler msg = new StringBundler(4);
291
292 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
293
294 msg.append("groupId=");
295 msg.append(groupId);
296
297 msg.append(StringPool.CLOSE_CURLY_BRACE);
298
299 throw new NoSuchStatsUserException(msg.toString());
300 }
301
302
309 @Override
310 public MBStatsUser fetchByGroupId_First(long groupId,
311 OrderByComparator<MBStatsUser> orderByComparator) {
312 List<MBStatsUser> list = findByGroupId(groupId, 0, 1, orderByComparator);
313
314 if (!list.isEmpty()) {
315 return list.get(0);
316 }
317
318 return null;
319 }
320
321
329 @Override
330 public MBStatsUser findByGroupId_Last(long groupId,
331 OrderByComparator<MBStatsUser> orderByComparator)
332 throws NoSuchStatsUserException {
333 MBStatsUser mbStatsUser = fetchByGroupId_Last(groupId, orderByComparator);
334
335 if (mbStatsUser != null) {
336 return mbStatsUser;
337 }
338
339 StringBundler msg = new StringBundler(4);
340
341 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
342
343 msg.append("groupId=");
344 msg.append(groupId);
345
346 msg.append(StringPool.CLOSE_CURLY_BRACE);
347
348 throw new NoSuchStatsUserException(msg.toString());
349 }
350
351
358 @Override
359 public MBStatsUser fetchByGroupId_Last(long groupId,
360 OrderByComparator<MBStatsUser> orderByComparator) {
361 int count = countByGroupId(groupId);
362
363 if (count == 0) {
364 return null;
365 }
366
367 List<MBStatsUser> list = findByGroupId(groupId, count - 1, count,
368 orderByComparator);
369
370 if (!list.isEmpty()) {
371 return list.get(0);
372 }
373
374 return null;
375 }
376
377
386 @Override
387 public MBStatsUser[] findByGroupId_PrevAndNext(long statsUserId,
388 long groupId, OrderByComparator<MBStatsUser> orderByComparator)
389 throws NoSuchStatsUserException {
390 MBStatsUser mbStatsUser = findByPrimaryKey(statsUserId);
391
392 Session session = null;
393
394 try {
395 session = openSession();
396
397 MBStatsUser[] array = new MBStatsUserImpl[3];
398
399 array[0] = getByGroupId_PrevAndNext(session, mbStatsUser, groupId,
400 orderByComparator, true);
401
402 array[1] = mbStatsUser;
403
404 array[2] = getByGroupId_PrevAndNext(session, mbStatsUser, groupId,
405 orderByComparator, false);
406
407 return array;
408 }
409 catch (Exception e) {
410 throw processException(e);
411 }
412 finally {
413 closeSession(session);
414 }
415 }
416
417 protected MBStatsUser getByGroupId_PrevAndNext(Session session,
418 MBStatsUser mbStatsUser, long groupId,
419 OrderByComparator<MBStatsUser> orderByComparator, boolean previous) {
420 StringBundler query = null;
421
422 if (orderByComparator != null) {
423 query = new StringBundler(6 +
424 (orderByComparator.getOrderByFields().length * 6));
425 }
426 else {
427 query = new StringBundler(3);
428 }
429
430 query.append(_SQL_SELECT_MBSTATSUSER_WHERE);
431
432 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
433
434 if (orderByComparator != null) {
435 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
436
437 if (orderByConditionFields.length > 0) {
438 query.append(WHERE_AND);
439 }
440
441 for (int i = 0; i < orderByConditionFields.length; i++) {
442 query.append(_ORDER_BY_ENTITY_ALIAS);
443 query.append(orderByConditionFields[i]);
444
445 if ((i + 1) < orderByConditionFields.length) {
446 if (orderByComparator.isAscending() ^ previous) {
447 query.append(WHERE_GREATER_THAN_HAS_NEXT);
448 }
449 else {
450 query.append(WHERE_LESSER_THAN_HAS_NEXT);
451 }
452 }
453 else {
454 if (orderByComparator.isAscending() ^ previous) {
455 query.append(WHERE_GREATER_THAN);
456 }
457 else {
458 query.append(WHERE_LESSER_THAN);
459 }
460 }
461 }
462
463 query.append(ORDER_BY_CLAUSE);
464
465 String[] orderByFields = orderByComparator.getOrderByFields();
466
467 for (int i = 0; i < orderByFields.length; i++) {
468 query.append(_ORDER_BY_ENTITY_ALIAS);
469 query.append(orderByFields[i]);
470
471 if ((i + 1) < orderByFields.length) {
472 if (orderByComparator.isAscending() ^ previous) {
473 query.append(ORDER_BY_ASC_HAS_NEXT);
474 }
475 else {
476 query.append(ORDER_BY_DESC_HAS_NEXT);
477 }
478 }
479 else {
480 if (orderByComparator.isAscending() ^ previous) {
481 query.append(ORDER_BY_ASC);
482 }
483 else {
484 query.append(ORDER_BY_DESC);
485 }
486 }
487 }
488 }
489 else {
490 query.append(MBStatsUserModelImpl.ORDER_BY_JPQL);
491 }
492
493 String sql = query.toString();
494
495 Query q = session.createQuery(sql);
496
497 q.setFirstResult(0);
498 q.setMaxResults(2);
499
500 QueryPos qPos = QueryPos.getInstance(q);
501
502 qPos.add(groupId);
503
504 if (orderByComparator != null) {
505 Object[] values = orderByComparator.getOrderByConditionValues(mbStatsUser);
506
507 for (Object value : values) {
508 qPos.add(value);
509 }
510 }
511
512 List<MBStatsUser> list = q.list();
513
514 if (list.size() == 2) {
515 return list.get(1);
516 }
517 else {
518 return null;
519 }
520 }
521
522
527 @Override
528 public void removeByGroupId(long groupId) {
529 for (MBStatsUser mbStatsUser : findByGroupId(groupId,
530 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
531 remove(mbStatsUser);
532 }
533 }
534
535
541 @Override
542 public int countByGroupId(long groupId) {
543 FinderPath finderPath = FINDER_PATH_COUNT_BY_GROUPID;
544
545 Object[] finderArgs = new Object[] { groupId };
546
547 Long count = (Long)finderCache.getResult(finderPath, finderArgs, this);
548
549 if (count == null) {
550 StringBundler query = new StringBundler(2);
551
552 query.append(_SQL_COUNT_MBSTATSUSER_WHERE);
553
554 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
555
556 String sql = query.toString();
557
558 Session session = null;
559
560 try {
561 session = openSession();
562
563 Query q = session.createQuery(sql);
564
565 QueryPos qPos = QueryPos.getInstance(q);
566
567 qPos.add(groupId);
568
569 count = (Long)q.uniqueResult();
570
571 finderCache.putResult(finderPath, finderArgs, count);
572 }
573 catch (Exception e) {
574 finderCache.removeResult(finderPath, finderArgs);
575
576 throw processException(e);
577 }
578 finally {
579 closeSession(session);
580 }
581 }
582
583 return count.intValue();
584 }
585
586 private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "mbStatsUser.groupId = ?";
587 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_USERID = new FinderPath(MBStatsUserModelImpl.ENTITY_CACHE_ENABLED,
588 MBStatsUserModelImpl.FINDER_CACHE_ENABLED, MBStatsUserImpl.class,
589 FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByUserId",
590 new String[] {
591 Long.class.getName(),
592
593 Integer.class.getName(), Integer.class.getName(),
594 OrderByComparator.class.getName()
595 });
596 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_USERID =
597 new FinderPath(MBStatsUserModelImpl.ENTITY_CACHE_ENABLED,
598 MBStatsUserModelImpl.FINDER_CACHE_ENABLED, MBStatsUserImpl.class,
599 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByUserId",
600 new String[] { Long.class.getName() },
601 MBStatsUserModelImpl.USERID_COLUMN_BITMASK |
602 MBStatsUserModelImpl.MESSAGECOUNT_COLUMN_BITMASK);
603 public static final FinderPath FINDER_PATH_COUNT_BY_USERID = new FinderPath(MBStatsUserModelImpl.ENTITY_CACHE_ENABLED,
604 MBStatsUserModelImpl.FINDER_CACHE_ENABLED, Long.class,
605 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByUserId",
606 new String[] { Long.class.getName() });
607
608
614 @Override
615 public List<MBStatsUser> findByUserId(long userId) {
616 return findByUserId(userId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
617 }
618
619
631 @Override
632 public List<MBStatsUser> findByUserId(long userId, int start, int end) {
633 return findByUserId(userId, start, end, null);
634 }
635
636
649 @Override
650 public List<MBStatsUser> findByUserId(long userId, int start, int end,
651 OrderByComparator<MBStatsUser> orderByComparator) {
652 return findByUserId(userId, start, end, orderByComparator, true);
653 }
654
655
669 @Override
670 public List<MBStatsUser> findByUserId(long userId, int start, int end,
671 OrderByComparator<MBStatsUser> orderByComparator,
672 boolean retrieveFromCache) {
673 boolean pagination = true;
674 FinderPath finderPath = null;
675 Object[] finderArgs = null;
676
677 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
678 (orderByComparator == null)) {
679 pagination = false;
680 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_USERID;
681 finderArgs = new Object[] { userId };
682 }
683 else {
684 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_USERID;
685 finderArgs = new Object[] { userId, start, end, orderByComparator };
686 }
687
688 List<MBStatsUser> list = null;
689
690 if (retrieveFromCache) {
691 list = (List<MBStatsUser>)finderCache.getResult(finderPath,
692 finderArgs, this);
693
694 if ((list != null) && !list.isEmpty()) {
695 for (MBStatsUser mbStatsUser : list) {
696 if ((userId != mbStatsUser.getUserId())) {
697 list = null;
698
699 break;
700 }
701 }
702 }
703 }
704
705 if (list == null) {
706 StringBundler query = null;
707
708 if (orderByComparator != null) {
709 query = new StringBundler(3 +
710 (orderByComparator.getOrderByFields().length * 3));
711 }
712 else {
713 query = new StringBundler(3);
714 }
715
716 query.append(_SQL_SELECT_MBSTATSUSER_WHERE);
717
718 query.append(_FINDER_COLUMN_USERID_USERID_2);
719
720 if (orderByComparator != null) {
721 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
722 orderByComparator);
723 }
724 else
725 if (pagination) {
726 query.append(MBStatsUserModelImpl.ORDER_BY_JPQL);
727 }
728
729 String sql = query.toString();
730
731 Session session = null;
732
733 try {
734 session = openSession();
735
736 Query q = session.createQuery(sql);
737
738 QueryPos qPos = QueryPos.getInstance(q);
739
740 qPos.add(userId);
741
742 if (!pagination) {
743 list = (List<MBStatsUser>)QueryUtil.list(q, getDialect(),
744 start, end, false);
745
746 Collections.sort(list);
747
748 list = Collections.unmodifiableList(list);
749 }
750 else {
751 list = (List<MBStatsUser>)QueryUtil.list(q, getDialect(),
752 start, end);
753 }
754
755 cacheResult(list);
756
757 finderCache.putResult(finderPath, finderArgs, list);
758 }
759 catch (Exception e) {
760 finderCache.removeResult(finderPath, finderArgs);
761
762 throw processException(e);
763 }
764 finally {
765 closeSession(session);
766 }
767 }
768
769 return list;
770 }
771
772
780 @Override
781 public MBStatsUser findByUserId_First(long userId,
782 OrderByComparator<MBStatsUser> orderByComparator)
783 throws NoSuchStatsUserException {
784 MBStatsUser mbStatsUser = fetchByUserId_First(userId, orderByComparator);
785
786 if (mbStatsUser != null) {
787 return mbStatsUser;
788 }
789
790 StringBundler msg = new StringBundler(4);
791
792 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
793
794 msg.append("userId=");
795 msg.append(userId);
796
797 msg.append(StringPool.CLOSE_CURLY_BRACE);
798
799 throw new NoSuchStatsUserException(msg.toString());
800 }
801
802
809 @Override
810 public MBStatsUser fetchByUserId_First(long userId,
811 OrderByComparator<MBStatsUser> orderByComparator) {
812 List<MBStatsUser> list = findByUserId(userId, 0, 1, orderByComparator);
813
814 if (!list.isEmpty()) {
815 return list.get(0);
816 }
817
818 return null;
819 }
820
821
829 @Override
830 public MBStatsUser findByUserId_Last(long userId,
831 OrderByComparator<MBStatsUser> orderByComparator)
832 throws NoSuchStatsUserException {
833 MBStatsUser mbStatsUser = fetchByUserId_Last(userId, orderByComparator);
834
835 if (mbStatsUser != null) {
836 return mbStatsUser;
837 }
838
839 StringBundler msg = new StringBundler(4);
840
841 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
842
843 msg.append("userId=");
844 msg.append(userId);
845
846 msg.append(StringPool.CLOSE_CURLY_BRACE);
847
848 throw new NoSuchStatsUserException(msg.toString());
849 }
850
851
858 @Override
859 public MBStatsUser fetchByUserId_Last(long userId,
860 OrderByComparator<MBStatsUser> orderByComparator) {
861 int count = countByUserId(userId);
862
863 if (count == 0) {
864 return null;
865 }
866
867 List<MBStatsUser> list = findByUserId(userId, count - 1, count,
868 orderByComparator);
869
870 if (!list.isEmpty()) {
871 return list.get(0);
872 }
873
874 return null;
875 }
876
877
886 @Override
887 public MBStatsUser[] findByUserId_PrevAndNext(long statsUserId,
888 long userId, OrderByComparator<MBStatsUser> orderByComparator)
889 throws NoSuchStatsUserException {
890 MBStatsUser mbStatsUser = findByPrimaryKey(statsUserId);
891
892 Session session = null;
893
894 try {
895 session = openSession();
896
897 MBStatsUser[] array = new MBStatsUserImpl[3];
898
899 array[0] = getByUserId_PrevAndNext(session, mbStatsUser, userId,
900 orderByComparator, true);
901
902 array[1] = mbStatsUser;
903
904 array[2] = getByUserId_PrevAndNext(session, mbStatsUser, userId,
905 orderByComparator, false);
906
907 return array;
908 }
909 catch (Exception e) {
910 throw processException(e);
911 }
912 finally {
913 closeSession(session);
914 }
915 }
916
917 protected MBStatsUser getByUserId_PrevAndNext(Session session,
918 MBStatsUser mbStatsUser, long userId,
919 OrderByComparator<MBStatsUser> orderByComparator, boolean previous) {
920 StringBundler query = null;
921
922 if (orderByComparator != null) {
923 query = new StringBundler(6 +
924 (orderByComparator.getOrderByFields().length * 6));
925 }
926 else {
927 query = new StringBundler(3);
928 }
929
930 query.append(_SQL_SELECT_MBSTATSUSER_WHERE);
931
932 query.append(_FINDER_COLUMN_USERID_USERID_2);
933
934 if (orderByComparator != null) {
935 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
936
937 if (orderByConditionFields.length > 0) {
938 query.append(WHERE_AND);
939 }
940
941 for (int i = 0; i < orderByConditionFields.length; i++) {
942 query.append(_ORDER_BY_ENTITY_ALIAS);
943 query.append(orderByConditionFields[i]);
944
945 if ((i + 1) < orderByConditionFields.length) {
946 if (orderByComparator.isAscending() ^ previous) {
947 query.append(WHERE_GREATER_THAN_HAS_NEXT);
948 }
949 else {
950 query.append(WHERE_LESSER_THAN_HAS_NEXT);
951 }
952 }
953 else {
954 if (orderByComparator.isAscending() ^ previous) {
955 query.append(WHERE_GREATER_THAN);
956 }
957 else {
958 query.append(WHERE_LESSER_THAN);
959 }
960 }
961 }
962
963 query.append(ORDER_BY_CLAUSE);
964
965 String[] orderByFields = orderByComparator.getOrderByFields();
966
967 for (int i = 0; i < orderByFields.length; i++) {
968 query.append(_ORDER_BY_ENTITY_ALIAS);
969 query.append(orderByFields[i]);
970
971 if ((i + 1) < orderByFields.length) {
972 if (orderByComparator.isAscending() ^ previous) {
973 query.append(ORDER_BY_ASC_HAS_NEXT);
974 }
975 else {
976 query.append(ORDER_BY_DESC_HAS_NEXT);
977 }
978 }
979 else {
980 if (orderByComparator.isAscending() ^ previous) {
981 query.append(ORDER_BY_ASC);
982 }
983 else {
984 query.append(ORDER_BY_DESC);
985 }
986 }
987 }
988 }
989 else {
990 query.append(MBStatsUserModelImpl.ORDER_BY_JPQL);
991 }
992
993 String sql = query.toString();
994
995 Query q = session.createQuery(sql);
996
997 q.setFirstResult(0);
998 q.setMaxResults(2);
999
1000 QueryPos qPos = QueryPos.getInstance(q);
1001
1002 qPos.add(userId);
1003
1004 if (orderByComparator != null) {
1005 Object[] values = orderByComparator.getOrderByConditionValues(mbStatsUser);
1006
1007 for (Object value : values) {
1008 qPos.add(value);
1009 }
1010 }
1011
1012 List<MBStatsUser> list = q.list();
1013
1014 if (list.size() == 2) {
1015 return list.get(1);
1016 }
1017 else {
1018 return null;
1019 }
1020 }
1021
1022
1027 @Override
1028 public void removeByUserId(long userId) {
1029 for (MBStatsUser mbStatsUser : findByUserId(userId, QueryUtil.ALL_POS,
1030 QueryUtil.ALL_POS, null)) {
1031 remove(mbStatsUser);
1032 }
1033 }
1034
1035
1041 @Override
1042 public int countByUserId(long userId) {
1043 FinderPath finderPath = FINDER_PATH_COUNT_BY_USERID;
1044
1045 Object[] finderArgs = new Object[] { userId };
1046
1047 Long count = (Long)finderCache.getResult(finderPath, finderArgs, this);
1048
1049 if (count == null) {
1050 StringBundler query = new StringBundler(2);
1051
1052 query.append(_SQL_COUNT_MBSTATSUSER_WHERE);
1053
1054 query.append(_FINDER_COLUMN_USERID_USERID_2);
1055
1056 String sql = query.toString();
1057
1058 Session session = null;
1059
1060 try {
1061 session = openSession();
1062
1063 Query q = session.createQuery(sql);
1064
1065 QueryPos qPos = QueryPos.getInstance(q);
1066
1067 qPos.add(userId);
1068
1069 count = (Long)q.uniqueResult();
1070
1071 finderCache.putResult(finderPath, finderArgs, count);
1072 }
1073 catch (Exception e) {
1074 finderCache.removeResult(finderPath, finderArgs);
1075
1076 throw processException(e);
1077 }
1078 finally {
1079 closeSession(session);
1080 }
1081 }
1082
1083 return count.intValue();
1084 }
1085
1086 private static final String _FINDER_COLUMN_USERID_USERID_2 = "mbStatsUser.userId = ?";
1087 public static final FinderPath FINDER_PATH_FETCH_BY_G_U = new FinderPath(MBStatsUserModelImpl.ENTITY_CACHE_ENABLED,
1088 MBStatsUserModelImpl.FINDER_CACHE_ENABLED, MBStatsUserImpl.class,
1089 FINDER_CLASS_NAME_ENTITY, "fetchByG_U",
1090 new String[] { Long.class.getName(), Long.class.getName() },
1091 MBStatsUserModelImpl.GROUPID_COLUMN_BITMASK |
1092 MBStatsUserModelImpl.USERID_COLUMN_BITMASK);
1093 public static final FinderPath FINDER_PATH_COUNT_BY_G_U = new FinderPath(MBStatsUserModelImpl.ENTITY_CACHE_ENABLED,
1094 MBStatsUserModelImpl.FINDER_CACHE_ENABLED, Long.class,
1095 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByG_U",
1096 new String[] { Long.class.getName(), Long.class.getName() });
1097
1098
1106 @Override
1107 public MBStatsUser findByG_U(long groupId, long userId)
1108 throws NoSuchStatsUserException {
1109 MBStatsUser mbStatsUser = fetchByG_U(groupId, userId);
1110
1111 if (mbStatsUser == null) {
1112 StringBundler msg = new StringBundler(6);
1113
1114 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1115
1116 msg.append("groupId=");
1117 msg.append(groupId);
1118
1119 msg.append(", userId=");
1120 msg.append(userId);
1121
1122 msg.append(StringPool.CLOSE_CURLY_BRACE);
1123
1124 if (_log.isWarnEnabled()) {
1125 _log.warn(msg.toString());
1126 }
1127
1128 throw new NoSuchStatsUserException(msg.toString());
1129 }
1130
1131 return mbStatsUser;
1132 }
1133
1134
1141 @Override
1142 public MBStatsUser fetchByG_U(long groupId, long userId) {
1143 return fetchByG_U(groupId, userId, true);
1144 }
1145
1146
1154 @Override
1155 public MBStatsUser fetchByG_U(long groupId, long userId,
1156 boolean retrieveFromCache) {
1157 Object[] finderArgs = new Object[] { groupId, userId };
1158
1159 Object result = null;
1160
1161 if (retrieveFromCache) {
1162 result = finderCache.getResult(FINDER_PATH_FETCH_BY_G_U,
1163 finderArgs, this);
1164 }
1165
1166 if (result instanceof MBStatsUser) {
1167 MBStatsUser mbStatsUser = (MBStatsUser)result;
1168
1169 if ((groupId != mbStatsUser.getGroupId()) ||
1170 (userId != mbStatsUser.getUserId())) {
1171 result = null;
1172 }
1173 }
1174
1175 if (result == null) {
1176 StringBundler query = new StringBundler(4);
1177
1178 query.append(_SQL_SELECT_MBSTATSUSER_WHERE);
1179
1180 query.append(_FINDER_COLUMN_G_U_GROUPID_2);
1181
1182 query.append(_FINDER_COLUMN_G_U_USERID_2);
1183
1184 String sql = query.toString();
1185
1186 Session session = null;
1187
1188 try {
1189 session = openSession();
1190
1191 Query q = session.createQuery(sql);
1192
1193 QueryPos qPos = QueryPos.getInstance(q);
1194
1195 qPos.add(groupId);
1196
1197 qPos.add(userId);
1198
1199 List<MBStatsUser> list = q.list();
1200
1201 if (list.isEmpty()) {
1202 finderCache.putResult(FINDER_PATH_FETCH_BY_G_U, finderArgs,
1203 list);
1204 }
1205 else {
1206 MBStatsUser mbStatsUser = list.get(0);
1207
1208 result = mbStatsUser;
1209
1210 cacheResult(mbStatsUser);
1211
1212 if ((mbStatsUser.getGroupId() != groupId) ||
1213 (mbStatsUser.getUserId() != userId)) {
1214 finderCache.putResult(FINDER_PATH_FETCH_BY_G_U,
1215 finderArgs, mbStatsUser);
1216 }
1217 }
1218 }
1219 catch (Exception e) {
1220 finderCache.removeResult(FINDER_PATH_FETCH_BY_G_U, finderArgs);
1221
1222 throw processException(e);
1223 }
1224 finally {
1225 closeSession(session);
1226 }
1227 }
1228
1229 if (result instanceof List<?>) {
1230 return null;
1231 }
1232 else {
1233 return (MBStatsUser)result;
1234 }
1235 }
1236
1237
1244 @Override
1245 public MBStatsUser removeByG_U(long groupId, long userId)
1246 throws NoSuchStatsUserException {
1247 MBStatsUser mbStatsUser = findByG_U(groupId, userId);
1248
1249 return remove(mbStatsUser);
1250 }
1251
1252
1259 @Override
1260 public int countByG_U(long groupId, long userId) {
1261 FinderPath finderPath = FINDER_PATH_COUNT_BY_G_U;
1262
1263 Object[] finderArgs = new Object[] { groupId, userId };
1264
1265 Long count = (Long)finderCache.getResult(finderPath, finderArgs, this);
1266
1267 if (count == null) {
1268 StringBundler query = new StringBundler(3);
1269
1270 query.append(_SQL_COUNT_MBSTATSUSER_WHERE);
1271
1272 query.append(_FINDER_COLUMN_G_U_GROUPID_2);
1273
1274 query.append(_FINDER_COLUMN_G_U_USERID_2);
1275
1276 String sql = query.toString();
1277
1278 Session session = null;
1279
1280 try {
1281 session = openSession();
1282
1283 Query q = session.createQuery(sql);
1284
1285 QueryPos qPos = QueryPos.getInstance(q);
1286
1287 qPos.add(groupId);
1288
1289 qPos.add(userId);
1290
1291 count = (Long)q.uniqueResult();
1292
1293 finderCache.putResult(finderPath, finderArgs, count);
1294 }
1295 catch (Exception e) {
1296 finderCache.removeResult(finderPath, finderArgs);
1297
1298 throw processException(e);
1299 }
1300 finally {
1301 closeSession(session);
1302 }
1303 }
1304
1305 return count.intValue();
1306 }
1307
1308 private static final String _FINDER_COLUMN_G_U_GROUPID_2 = "mbStatsUser.groupId = ? AND ";
1309 private static final String _FINDER_COLUMN_G_U_USERID_2 = "mbStatsUser.userId = ?";
1310 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_G_NOTU_NOTM =
1311 new FinderPath(MBStatsUserModelImpl.ENTITY_CACHE_ENABLED,
1312 MBStatsUserModelImpl.FINDER_CACHE_ENABLED, MBStatsUserImpl.class,
1313 FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByG_NotU_NotM",
1314 new String[] {
1315 Long.class.getName(), Long.class.getName(),
1316 Integer.class.getName(),
1317
1318 Integer.class.getName(), Integer.class.getName(),
1319 OrderByComparator.class.getName()
1320 });
1321 public static final FinderPath FINDER_PATH_WITH_PAGINATION_COUNT_BY_G_NOTU_NOTM =
1322 new FinderPath(MBStatsUserModelImpl.ENTITY_CACHE_ENABLED,
1323 MBStatsUserModelImpl.FINDER_CACHE_ENABLED, Long.class,
1324 FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "countByG_NotU_NotM",
1325 new String[] {
1326 Long.class.getName(), Long.class.getName(),
1327 Integer.class.getName()
1328 });
1329
1330
1338 @Override
1339 public List<MBStatsUser> findByG_NotU_NotM(long groupId, long userId,
1340 int messageCount) {
1341 return findByG_NotU_NotM(groupId, userId, messageCount,
1342 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1343 }
1344
1345
1359 @Override
1360 public List<MBStatsUser> findByG_NotU_NotM(long groupId, long userId,
1361 int messageCount, int start, int end) {
1362 return findByG_NotU_NotM(groupId, userId, messageCount, start, end, null);
1363 }
1364
1365
1380 @Override
1381 public List<MBStatsUser> findByG_NotU_NotM(long groupId, long userId,
1382 int messageCount, int start, int end,
1383 OrderByComparator<MBStatsUser> orderByComparator) {
1384 return findByG_NotU_NotM(groupId, userId, messageCount, start, end,
1385 orderByComparator, true);
1386 }
1387
1388
1404 @Override
1405 public List<MBStatsUser> findByG_NotU_NotM(long groupId, long userId,
1406 int messageCount, int start, int end,
1407 OrderByComparator<MBStatsUser> orderByComparator,
1408 boolean retrieveFromCache) {
1409 boolean pagination = true;
1410 FinderPath finderPath = null;
1411 Object[] finderArgs = null;
1412
1413 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_G_NOTU_NOTM;
1414 finderArgs = new Object[] {
1415 groupId, userId, messageCount,
1416
1417 start, end, orderByComparator
1418 };
1419
1420 List<MBStatsUser> list = null;
1421
1422 if (retrieveFromCache) {
1423 list = (List<MBStatsUser>)finderCache.getResult(finderPath,
1424 finderArgs, this);
1425
1426 if ((list != null) && !list.isEmpty()) {
1427 for (MBStatsUser mbStatsUser : list) {
1428 if ((groupId != mbStatsUser.getGroupId()) ||
1429 (userId == mbStatsUser.getUserId()) ||
1430 (messageCount == mbStatsUser.getMessageCount())) {
1431 list = null;
1432
1433 break;
1434 }
1435 }
1436 }
1437 }
1438
1439 if (list == null) {
1440 StringBundler query = null;
1441
1442 if (orderByComparator != null) {
1443 query = new StringBundler(5 +
1444 (orderByComparator.getOrderByFields().length * 3));
1445 }
1446 else {
1447 query = new StringBundler(5);
1448 }
1449
1450 query.append(_SQL_SELECT_MBSTATSUSER_WHERE);
1451
1452 query.append(_FINDER_COLUMN_G_NOTU_NOTM_GROUPID_2);
1453
1454 query.append(_FINDER_COLUMN_G_NOTU_NOTM_USERID_2);
1455
1456 query.append(_FINDER_COLUMN_G_NOTU_NOTM_MESSAGECOUNT_2);
1457
1458 if (orderByComparator != null) {
1459 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1460 orderByComparator);
1461 }
1462 else
1463 if (pagination) {
1464 query.append(MBStatsUserModelImpl.ORDER_BY_JPQL);
1465 }
1466
1467 String sql = query.toString();
1468
1469 Session session = null;
1470
1471 try {
1472 session = openSession();
1473
1474 Query q = session.createQuery(sql);
1475
1476 QueryPos qPos = QueryPos.getInstance(q);
1477
1478 qPos.add(groupId);
1479
1480 qPos.add(userId);
1481
1482 qPos.add(messageCount);
1483
1484 if (!pagination) {
1485 list = (List<MBStatsUser>)QueryUtil.list(q, getDialect(),
1486 start, end, false);
1487
1488 Collections.sort(list);
1489
1490 list = Collections.unmodifiableList(list);
1491 }
1492 else {
1493 list = (List<MBStatsUser>)QueryUtil.list(q, getDialect(),
1494 start, end);
1495 }
1496
1497 cacheResult(list);
1498
1499 finderCache.putResult(finderPath, finderArgs, list);
1500 }
1501 catch (Exception e) {
1502 finderCache.removeResult(finderPath, finderArgs);
1503
1504 throw processException(e);
1505 }
1506 finally {
1507 closeSession(session);
1508 }
1509 }
1510
1511 return list;
1512 }
1513
1514
1524 @Override
1525 public MBStatsUser findByG_NotU_NotM_First(long groupId, long userId,
1526 int messageCount, OrderByComparator<MBStatsUser> orderByComparator)
1527 throws NoSuchStatsUserException {
1528 MBStatsUser mbStatsUser = fetchByG_NotU_NotM_First(groupId, userId,
1529 messageCount, orderByComparator);
1530
1531 if (mbStatsUser != null) {
1532 return mbStatsUser;
1533 }
1534
1535 StringBundler msg = new StringBundler(8);
1536
1537 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1538
1539 msg.append("groupId=");
1540 msg.append(groupId);
1541
1542 msg.append(", userId=");
1543 msg.append(userId);
1544
1545 msg.append(", messageCount=");
1546 msg.append(messageCount);
1547
1548 msg.append(StringPool.CLOSE_CURLY_BRACE);
1549
1550 throw new NoSuchStatsUserException(msg.toString());
1551 }
1552
1553
1562 @Override
1563 public MBStatsUser fetchByG_NotU_NotM_First(long groupId, long userId,
1564 int messageCount, OrderByComparator<MBStatsUser> orderByComparator) {
1565 List<MBStatsUser> list = findByG_NotU_NotM(groupId, userId,
1566 messageCount, 0, 1, orderByComparator);
1567
1568 if (!list.isEmpty()) {
1569 return list.get(0);
1570 }
1571
1572 return null;
1573 }
1574
1575
1585 @Override
1586 public MBStatsUser findByG_NotU_NotM_Last(long groupId, long userId,
1587 int messageCount, OrderByComparator<MBStatsUser> orderByComparator)
1588 throws NoSuchStatsUserException {
1589 MBStatsUser mbStatsUser = fetchByG_NotU_NotM_Last(groupId, userId,
1590 messageCount, orderByComparator);
1591
1592 if (mbStatsUser != null) {
1593 return mbStatsUser;
1594 }
1595
1596 StringBundler msg = new StringBundler(8);
1597
1598 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1599
1600 msg.append("groupId=");
1601 msg.append(groupId);
1602
1603 msg.append(", userId=");
1604 msg.append(userId);
1605
1606 msg.append(", messageCount=");
1607 msg.append(messageCount);
1608
1609 msg.append(StringPool.CLOSE_CURLY_BRACE);
1610
1611 throw new NoSuchStatsUserException(msg.toString());
1612 }
1613
1614
1623 @Override
1624 public MBStatsUser fetchByG_NotU_NotM_Last(long groupId, long userId,
1625 int messageCount, OrderByComparator<MBStatsUser> orderByComparator) {
1626 int count = countByG_NotU_NotM(groupId, userId, messageCount);
1627
1628 if (count == 0) {
1629 return null;
1630 }
1631
1632 List<MBStatsUser> list = findByG_NotU_NotM(groupId, userId,
1633 messageCount, count - 1, count, orderByComparator);
1634
1635 if (!list.isEmpty()) {
1636 return list.get(0);
1637 }
1638
1639 return null;
1640 }
1641
1642
1653 @Override
1654 public MBStatsUser[] findByG_NotU_NotM_PrevAndNext(long statsUserId,
1655 long groupId, long userId, int messageCount,
1656 OrderByComparator<MBStatsUser> orderByComparator)
1657 throws NoSuchStatsUserException {
1658 MBStatsUser mbStatsUser = findByPrimaryKey(statsUserId);
1659
1660 Session session = null;
1661
1662 try {
1663 session = openSession();
1664
1665 MBStatsUser[] array = new MBStatsUserImpl[3];
1666
1667 array[0] = getByG_NotU_NotM_PrevAndNext(session, mbStatsUser,
1668 groupId, userId, messageCount, orderByComparator, true);
1669
1670 array[1] = mbStatsUser;
1671
1672 array[2] = getByG_NotU_NotM_PrevAndNext(session, mbStatsUser,
1673 groupId, userId, messageCount, orderByComparator, false);
1674
1675 return array;
1676 }
1677 catch (Exception e) {
1678 throw processException(e);
1679 }
1680 finally {
1681 closeSession(session);
1682 }
1683 }
1684
1685 protected MBStatsUser getByG_NotU_NotM_PrevAndNext(Session session,
1686 MBStatsUser mbStatsUser, long groupId, long userId, int messageCount,
1687 OrderByComparator<MBStatsUser> orderByComparator, boolean previous) {
1688 StringBundler query = null;
1689
1690 if (orderByComparator != null) {
1691 query = new StringBundler(6 +
1692 (orderByComparator.getOrderByFields().length * 6));
1693 }
1694 else {
1695 query = new StringBundler(3);
1696 }
1697
1698 query.append(_SQL_SELECT_MBSTATSUSER_WHERE);
1699
1700 query.append(_FINDER_COLUMN_G_NOTU_NOTM_GROUPID_2);
1701
1702 query.append(_FINDER_COLUMN_G_NOTU_NOTM_USERID_2);
1703
1704 query.append(_FINDER_COLUMN_G_NOTU_NOTM_MESSAGECOUNT_2);
1705
1706 if (orderByComparator != null) {
1707 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
1708
1709 if (orderByConditionFields.length > 0) {
1710 query.append(WHERE_AND);
1711 }
1712
1713 for (int i = 0; i < orderByConditionFields.length; i++) {
1714 query.append(_ORDER_BY_ENTITY_ALIAS);
1715 query.append(orderByConditionFields[i]);
1716
1717 if ((i + 1) < orderByConditionFields.length) {
1718 if (orderByComparator.isAscending() ^ previous) {
1719 query.append(WHERE_GREATER_THAN_HAS_NEXT);
1720 }
1721 else {
1722 query.append(WHERE_LESSER_THAN_HAS_NEXT);
1723 }
1724 }
1725 else {
1726 if (orderByComparator.isAscending() ^ previous) {
1727 query.append(WHERE_GREATER_THAN);
1728 }
1729 else {
1730 query.append(WHERE_LESSER_THAN);
1731 }
1732 }
1733 }
1734
1735 query.append(ORDER_BY_CLAUSE);
1736
1737 String[] orderByFields = orderByComparator.getOrderByFields();
1738
1739 for (int i = 0; i < orderByFields.length; i++) {
1740 query.append(_ORDER_BY_ENTITY_ALIAS);
1741 query.append(orderByFields[i]);
1742
1743 if ((i + 1) < orderByFields.length) {
1744 if (orderByComparator.isAscending() ^ previous) {
1745 query.append(ORDER_BY_ASC_HAS_NEXT);
1746 }
1747 else {
1748 query.append(ORDER_BY_DESC_HAS_NEXT);
1749 }
1750 }
1751 else {
1752 if (orderByComparator.isAscending() ^ previous) {
1753 query.append(ORDER_BY_ASC);
1754 }
1755 else {
1756 query.append(ORDER_BY_DESC);
1757 }
1758 }
1759 }
1760 }
1761 else {
1762 query.append(MBStatsUserModelImpl.ORDER_BY_JPQL);
1763 }
1764
1765 String sql = query.toString();
1766
1767 Query q = session.createQuery(sql);
1768
1769 q.setFirstResult(0);
1770 q.setMaxResults(2);
1771
1772 QueryPos qPos = QueryPos.getInstance(q);
1773
1774 qPos.add(groupId);
1775
1776 qPos.add(userId);
1777
1778 qPos.add(messageCount);
1779
1780 if (orderByComparator != null) {
1781 Object[] values = orderByComparator.getOrderByConditionValues(mbStatsUser);
1782
1783 for (Object value : values) {
1784 qPos.add(value);
1785 }
1786 }
1787
1788 List<MBStatsUser> list = q.list();
1789
1790 if (list.size() == 2) {
1791 return list.get(1);
1792 }
1793 else {
1794 return null;
1795 }
1796 }
1797
1798
1805 @Override
1806 public void removeByG_NotU_NotM(long groupId, long userId, int messageCount) {
1807 for (MBStatsUser mbStatsUser : findByG_NotU_NotM(groupId, userId,
1808 messageCount, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
1809 remove(mbStatsUser);
1810 }
1811 }
1812
1813
1821 @Override
1822 public int countByG_NotU_NotM(long groupId, long userId, int messageCount) {
1823 FinderPath finderPath = FINDER_PATH_WITH_PAGINATION_COUNT_BY_G_NOTU_NOTM;
1824
1825 Object[] finderArgs = new Object[] { groupId, userId, messageCount };
1826
1827 Long count = (Long)finderCache.getResult(finderPath, finderArgs, this);
1828
1829 if (count == null) {
1830 StringBundler query = new StringBundler(4);
1831
1832 query.append(_SQL_COUNT_MBSTATSUSER_WHERE);
1833
1834 query.append(_FINDER_COLUMN_G_NOTU_NOTM_GROUPID_2);
1835
1836 query.append(_FINDER_COLUMN_G_NOTU_NOTM_USERID_2);
1837
1838 query.append(_FINDER_COLUMN_G_NOTU_NOTM_MESSAGECOUNT_2);
1839
1840 String sql = query.toString();
1841
1842 Session session = null;
1843
1844 try {
1845 session = openSession();
1846
1847 Query q = session.createQuery(sql);
1848
1849 QueryPos qPos = QueryPos.getInstance(q);
1850
1851 qPos.add(groupId);
1852
1853 qPos.add(userId);
1854
1855 qPos.add(messageCount);
1856
1857 count = (Long)q.uniqueResult();
1858
1859 finderCache.putResult(finderPath, finderArgs, count);
1860 }
1861 catch (Exception e) {
1862 finderCache.removeResult(finderPath, finderArgs);
1863
1864 throw processException(e);
1865 }
1866 finally {
1867 closeSession(session);
1868 }
1869 }
1870
1871 return count.intValue();
1872 }
1873
1874 private static final String _FINDER_COLUMN_G_NOTU_NOTM_GROUPID_2 = "mbStatsUser.groupId = ? AND ";
1875 private static final String _FINDER_COLUMN_G_NOTU_NOTM_USERID_2 = "mbStatsUser.userId != ? AND ";
1876 private static final String _FINDER_COLUMN_G_NOTU_NOTM_MESSAGECOUNT_2 = "mbStatsUser.messageCount != ?";
1877
1878 public MBStatsUserPersistenceImpl() {
1879 setModelClass(MBStatsUser.class);
1880 }
1881
1882
1887 @Override
1888 public void cacheResult(MBStatsUser mbStatsUser) {
1889 entityCache.putResult(MBStatsUserModelImpl.ENTITY_CACHE_ENABLED,
1890 MBStatsUserImpl.class, mbStatsUser.getPrimaryKey(), mbStatsUser);
1891
1892 finderCache.putResult(FINDER_PATH_FETCH_BY_G_U,
1893 new Object[] { mbStatsUser.getGroupId(), mbStatsUser.getUserId() },
1894 mbStatsUser);
1895
1896 mbStatsUser.resetOriginalValues();
1897 }
1898
1899
1904 @Override
1905 public void cacheResult(List<MBStatsUser> mbStatsUsers) {
1906 for (MBStatsUser mbStatsUser : mbStatsUsers) {
1907 if (entityCache.getResult(
1908 MBStatsUserModelImpl.ENTITY_CACHE_ENABLED,
1909 MBStatsUserImpl.class, mbStatsUser.getPrimaryKey()) == null) {
1910 cacheResult(mbStatsUser);
1911 }
1912 else {
1913 mbStatsUser.resetOriginalValues();
1914 }
1915 }
1916 }
1917
1918
1925 @Override
1926 public void clearCache() {
1927 entityCache.clearCache(MBStatsUserImpl.class);
1928
1929 finderCache.clearCache(FINDER_CLASS_NAME_ENTITY);
1930 finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
1931 finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
1932 }
1933
1934
1941 @Override
1942 public void clearCache(MBStatsUser mbStatsUser) {
1943 entityCache.removeResult(MBStatsUserModelImpl.ENTITY_CACHE_ENABLED,
1944 MBStatsUserImpl.class, mbStatsUser.getPrimaryKey());
1945
1946 finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
1947 finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
1948
1949 clearUniqueFindersCache((MBStatsUserModelImpl)mbStatsUser);
1950 }
1951
1952 @Override
1953 public void clearCache(List<MBStatsUser> mbStatsUsers) {
1954 finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
1955 finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
1956
1957 for (MBStatsUser mbStatsUser : mbStatsUsers) {
1958 entityCache.removeResult(MBStatsUserModelImpl.ENTITY_CACHE_ENABLED,
1959 MBStatsUserImpl.class, mbStatsUser.getPrimaryKey());
1960
1961 clearUniqueFindersCache((MBStatsUserModelImpl)mbStatsUser);
1962 }
1963 }
1964
1965 protected void cacheUniqueFindersCache(
1966 MBStatsUserModelImpl mbStatsUserModelImpl, boolean isNew) {
1967 if (isNew) {
1968 Object[] args = new Object[] {
1969 mbStatsUserModelImpl.getGroupId(),
1970 mbStatsUserModelImpl.getUserId()
1971 };
1972
1973 finderCache.putResult(FINDER_PATH_COUNT_BY_G_U, args,
1974 Long.valueOf(1));
1975 finderCache.putResult(FINDER_PATH_FETCH_BY_G_U, args,
1976 mbStatsUserModelImpl);
1977 }
1978 else {
1979 if ((mbStatsUserModelImpl.getColumnBitmask() &
1980 FINDER_PATH_FETCH_BY_G_U.getColumnBitmask()) != 0) {
1981 Object[] args = new Object[] {
1982 mbStatsUserModelImpl.getGroupId(),
1983 mbStatsUserModelImpl.getUserId()
1984 };
1985
1986 finderCache.putResult(FINDER_PATH_COUNT_BY_G_U, args,
1987 Long.valueOf(1));
1988 finderCache.putResult(FINDER_PATH_FETCH_BY_G_U, args,
1989 mbStatsUserModelImpl);
1990 }
1991 }
1992 }
1993
1994 protected void clearUniqueFindersCache(
1995 MBStatsUserModelImpl mbStatsUserModelImpl) {
1996 Object[] args = new Object[] {
1997 mbStatsUserModelImpl.getGroupId(),
1998 mbStatsUserModelImpl.getUserId()
1999 };
2000
2001 finderCache.removeResult(FINDER_PATH_COUNT_BY_G_U, args);
2002 finderCache.removeResult(FINDER_PATH_FETCH_BY_G_U, args);
2003
2004 if ((mbStatsUserModelImpl.getColumnBitmask() &
2005 FINDER_PATH_FETCH_BY_G_U.getColumnBitmask()) != 0) {
2006 args = new Object[] {
2007 mbStatsUserModelImpl.getOriginalGroupId(),
2008 mbStatsUserModelImpl.getOriginalUserId()
2009 };
2010
2011 finderCache.removeResult(FINDER_PATH_COUNT_BY_G_U, args);
2012 finderCache.removeResult(FINDER_PATH_FETCH_BY_G_U, args);
2013 }
2014 }
2015
2016
2022 @Override
2023 public MBStatsUser create(long statsUserId) {
2024 MBStatsUser mbStatsUser = new MBStatsUserImpl();
2025
2026 mbStatsUser.setNew(true);
2027 mbStatsUser.setPrimaryKey(statsUserId);
2028
2029 return mbStatsUser;
2030 }
2031
2032
2039 @Override
2040 public MBStatsUser remove(long statsUserId) throws NoSuchStatsUserException {
2041 return remove((Serializable)statsUserId);
2042 }
2043
2044
2051 @Override
2052 public MBStatsUser remove(Serializable primaryKey)
2053 throws NoSuchStatsUserException {
2054 Session session = null;
2055
2056 try {
2057 session = openSession();
2058
2059 MBStatsUser mbStatsUser = (MBStatsUser)session.get(MBStatsUserImpl.class,
2060 primaryKey);
2061
2062 if (mbStatsUser == null) {
2063 if (_log.isWarnEnabled()) {
2064 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey);
2065 }
2066
2067 throw new NoSuchStatsUserException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
2068 primaryKey);
2069 }
2070
2071 return remove(mbStatsUser);
2072 }
2073 catch (NoSuchStatsUserException nsee) {
2074 throw nsee;
2075 }
2076 catch (Exception e) {
2077 throw processException(e);
2078 }
2079 finally {
2080 closeSession(session);
2081 }
2082 }
2083
2084 @Override
2085 protected MBStatsUser removeImpl(MBStatsUser mbStatsUser) {
2086 mbStatsUser = toUnwrappedModel(mbStatsUser);
2087
2088 Session session = null;
2089
2090 try {
2091 session = openSession();
2092
2093 if (!session.contains(mbStatsUser)) {
2094 mbStatsUser = (MBStatsUser)session.get(MBStatsUserImpl.class,
2095 mbStatsUser.getPrimaryKeyObj());
2096 }
2097
2098 if (mbStatsUser != null) {
2099 session.delete(mbStatsUser);
2100 }
2101 }
2102 catch (Exception e) {
2103 throw processException(e);
2104 }
2105 finally {
2106 closeSession(session);
2107 }
2108
2109 if (mbStatsUser != null) {
2110 clearCache(mbStatsUser);
2111 }
2112
2113 return mbStatsUser;
2114 }
2115
2116 @Override
2117 public MBStatsUser updateImpl(MBStatsUser mbStatsUser) {
2118 mbStatsUser = toUnwrappedModel(mbStatsUser);
2119
2120 boolean isNew = mbStatsUser.isNew();
2121
2122 MBStatsUserModelImpl mbStatsUserModelImpl = (MBStatsUserModelImpl)mbStatsUser;
2123
2124 Session session = null;
2125
2126 try {
2127 session = openSession();
2128
2129 if (mbStatsUser.isNew()) {
2130 session.save(mbStatsUser);
2131
2132 mbStatsUser.setNew(false);
2133 }
2134 else {
2135 mbStatsUser = (MBStatsUser)session.merge(mbStatsUser);
2136 }
2137 }
2138 catch (Exception e) {
2139 throw processException(e);
2140 }
2141 finally {
2142 closeSession(session);
2143 }
2144
2145 finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
2146
2147 if (isNew || !MBStatsUserModelImpl.COLUMN_BITMASK_ENABLED) {
2148 finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
2149 }
2150
2151 else {
2152 if ((mbStatsUserModelImpl.getColumnBitmask() &
2153 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID.getColumnBitmask()) != 0) {
2154 Object[] args = new Object[] {
2155 mbStatsUserModelImpl.getOriginalGroupId()
2156 };
2157
2158 finderCache.removeResult(FINDER_PATH_COUNT_BY_GROUPID, args);
2159 finderCache.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID,
2160 args);
2161
2162 args = new Object[] { mbStatsUserModelImpl.getGroupId() };
2163
2164 finderCache.removeResult(FINDER_PATH_COUNT_BY_GROUPID, args);
2165 finderCache.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID,
2166 args);
2167 }
2168
2169 if ((mbStatsUserModelImpl.getColumnBitmask() &
2170 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_USERID.getColumnBitmask()) != 0) {
2171 Object[] args = new Object[] {
2172 mbStatsUserModelImpl.getOriginalUserId()
2173 };
2174
2175 finderCache.removeResult(FINDER_PATH_COUNT_BY_USERID, args);
2176 finderCache.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_USERID,
2177 args);
2178
2179 args = new Object[] { mbStatsUserModelImpl.getUserId() };
2180
2181 finderCache.removeResult(FINDER_PATH_COUNT_BY_USERID, args);
2182 finderCache.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_USERID,
2183 args);
2184 }
2185 }
2186
2187 entityCache.putResult(MBStatsUserModelImpl.ENTITY_CACHE_ENABLED,
2188 MBStatsUserImpl.class, mbStatsUser.getPrimaryKey(), mbStatsUser,
2189 false);
2190
2191 clearUniqueFindersCache(mbStatsUserModelImpl);
2192 cacheUniqueFindersCache(mbStatsUserModelImpl, isNew);
2193
2194 mbStatsUser.resetOriginalValues();
2195
2196 return mbStatsUser;
2197 }
2198
2199 protected MBStatsUser toUnwrappedModel(MBStatsUser mbStatsUser) {
2200 if (mbStatsUser instanceof MBStatsUserImpl) {
2201 return mbStatsUser;
2202 }
2203
2204 MBStatsUserImpl mbStatsUserImpl = new MBStatsUserImpl();
2205
2206 mbStatsUserImpl.setNew(mbStatsUser.isNew());
2207 mbStatsUserImpl.setPrimaryKey(mbStatsUser.getPrimaryKey());
2208
2209 mbStatsUserImpl.setStatsUserId(mbStatsUser.getStatsUserId());
2210 mbStatsUserImpl.setGroupId(mbStatsUser.getGroupId());
2211 mbStatsUserImpl.setUserId(mbStatsUser.getUserId());
2212 mbStatsUserImpl.setMessageCount(mbStatsUser.getMessageCount());
2213 mbStatsUserImpl.setLastPostDate(mbStatsUser.getLastPostDate());
2214
2215 return mbStatsUserImpl;
2216 }
2217
2218
2225 @Override
2226 public MBStatsUser findByPrimaryKey(Serializable primaryKey)
2227 throws NoSuchStatsUserException {
2228 MBStatsUser mbStatsUser = fetchByPrimaryKey(primaryKey);
2229
2230 if (mbStatsUser == null) {
2231 if (_log.isWarnEnabled()) {
2232 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey);
2233 }
2234
2235 throw new NoSuchStatsUserException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
2236 primaryKey);
2237 }
2238
2239 return mbStatsUser;
2240 }
2241
2242
2249 @Override
2250 public MBStatsUser findByPrimaryKey(long statsUserId)
2251 throws NoSuchStatsUserException {
2252 return findByPrimaryKey((Serializable)statsUserId);
2253 }
2254
2255
2261 @Override
2262 public MBStatsUser fetchByPrimaryKey(Serializable primaryKey) {
2263 MBStatsUser mbStatsUser = (MBStatsUser)entityCache.getResult(MBStatsUserModelImpl.ENTITY_CACHE_ENABLED,
2264 MBStatsUserImpl.class, primaryKey);
2265
2266 if (mbStatsUser == _nullMBStatsUser) {
2267 return null;
2268 }
2269
2270 if (mbStatsUser == null) {
2271 Session session = null;
2272
2273 try {
2274 session = openSession();
2275
2276 mbStatsUser = (MBStatsUser)session.get(MBStatsUserImpl.class,
2277 primaryKey);
2278
2279 if (mbStatsUser != null) {
2280 cacheResult(mbStatsUser);
2281 }
2282 else {
2283 entityCache.putResult(MBStatsUserModelImpl.ENTITY_CACHE_ENABLED,
2284 MBStatsUserImpl.class, primaryKey, _nullMBStatsUser);
2285 }
2286 }
2287 catch (Exception e) {
2288 entityCache.removeResult(MBStatsUserModelImpl.ENTITY_CACHE_ENABLED,
2289 MBStatsUserImpl.class, primaryKey);
2290
2291 throw processException(e);
2292 }
2293 finally {
2294 closeSession(session);
2295 }
2296 }
2297
2298 return mbStatsUser;
2299 }
2300
2301
2307 @Override
2308 public MBStatsUser fetchByPrimaryKey(long statsUserId) {
2309 return fetchByPrimaryKey((Serializable)statsUserId);
2310 }
2311
2312 @Override
2313 public Map<Serializable, MBStatsUser> fetchByPrimaryKeys(
2314 Set<Serializable> primaryKeys) {
2315 if (primaryKeys.isEmpty()) {
2316 return Collections.emptyMap();
2317 }
2318
2319 Map<Serializable, MBStatsUser> map = new HashMap<Serializable, MBStatsUser>();
2320
2321 if (primaryKeys.size() == 1) {
2322 Iterator<Serializable> iterator = primaryKeys.iterator();
2323
2324 Serializable primaryKey = iterator.next();
2325
2326 MBStatsUser mbStatsUser = fetchByPrimaryKey(primaryKey);
2327
2328 if (mbStatsUser != null) {
2329 map.put(primaryKey, mbStatsUser);
2330 }
2331
2332 return map;
2333 }
2334
2335 Set<Serializable> uncachedPrimaryKeys = null;
2336
2337 for (Serializable primaryKey : primaryKeys) {
2338 MBStatsUser mbStatsUser = (MBStatsUser)entityCache.getResult(MBStatsUserModelImpl.ENTITY_CACHE_ENABLED,
2339 MBStatsUserImpl.class, primaryKey);
2340
2341 if (mbStatsUser == null) {
2342 if (uncachedPrimaryKeys == null) {
2343 uncachedPrimaryKeys = new HashSet<Serializable>();
2344 }
2345
2346 uncachedPrimaryKeys.add(primaryKey);
2347 }
2348 else {
2349 map.put(primaryKey, mbStatsUser);
2350 }
2351 }
2352
2353 if (uncachedPrimaryKeys == null) {
2354 return map;
2355 }
2356
2357 StringBundler query = new StringBundler((uncachedPrimaryKeys.size() * 2) +
2358 1);
2359
2360 query.append(_SQL_SELECT_MBSTATSUSER_WHERE_PKS_IN);
2361
2362 for (Serializable primaryKey : uncachedPrimaryKeys) {
2363 query.append(String.valueOf(primaryKey));
2364
2365 query.append(StringPool.COMMA);
2366 }
2367
2368 query.setIndex(query.index() - 1);
2369
2370 query.append(StringPool.CLOSE_PARENTHESIS);
2371
2372 String sql = query.toString();
2373
2374 Session session = null;
2375
2376 try {
2377 session = openSession();
2378
2379 Query q = session.createQuery(sql);
2380
2381 for (MBStatsUser mbStatsUser : (List<MBStatsUser>)q.list()) {
2382 map.put(mbStatsUser.getPrimaryKeyObj(), mbStatsUser);
2383
2384 cacheResult(mbStatsUser);
2385
2386 uncachedPrimaryKeys.remove(mbStatsUser.getPrimaryKeyObj());
2387 }
2388
2389 for (Serializable primaryKey : uncachedPrimaryKeys) {
2390 entityCache.putResult(MBStatsUserModelImpl.ENTITY_CACHE_ENABLED,
2391 MBStatsUserImpl.class, primaryKey, _nullMBStatsUser);
2392 }
2393 }
2394 catch (Exception e) {
2395 throw processException(e);
2396 }
2397 finally {
2398 closeSession(session);
2399 }
2400
2401 return map;
2402 }
2403
2404
2409 @Override
2410 public List<MBStatsUser> findAll() {
2411 return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
2412 }
2413
2414
2425 @Override
2426 public List<MBStatsUser> findAll(int start, int end) {
2427 return findAll(start, end, null);
2428 }
2429
2430
2442 @Override
2443 public List<MBStatsUser> findAll(int start, int end,
2444 OrderByComparator<MBStatsUser> orderByComparator) {
2445 return findAll(start, end, orderByComparator, true);
2446 }
2447
2448
2461 @Override
2462 public List<MBStatsUser> findAll(int start, int end,
2463 OrderByComparator<MBStatsUser> orderByComparator,
2464 boolean retrieveFromCache) {
2465 boolean pagination = true;
2466 FinderPath finderPath = null;
2467 Object[] finderArgs = null;
2468
2469 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
2470 (orderByComparator == null)) {
2471 pagination = false;
2472 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL;
2473 finderArgs = FINDER_ARGS_EMPTY;
2474 }
2475 else {
2476 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_ALL;
2477 finderArgs = new Object[] { start, end, orderByComparator };
2478 }
2479
2480 List<MBStatsUser> list = null;
2481
2482 if (retrieveFromCache) {
2483 list = (List<MBStatsUser>)finderCache.getResult(finderPath,
2484 finderArgs, this);
2485 }
2486
2487 if (list == null) {
2488 StringBundler query = null;
2489 String sql = null;
2490
2491 if (orderByComparator != null) {
2492 query = new StringBundler(2 +
2493 (orderByComparator.getOrderByFields().length * 3));
2494
2495 query.append(_SQL_SELECT_MBSTATSUSER);
2496
2497 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2498 orderByComparator);
2499
2500 sql = query.toString();
2501 }
2502 else {
2503 sql = _SQL_SELECT_MBSTATSUSER;
2504
2505 if (pagination) {
2506 sql = sql.concat(MBStatsUserModelImpl.ORDER_BY_JPQL);
2507 }
2508 }
2509
2510 Session session = null;
2511
2512 try {
2513 session = openSession();
2514
2515 Query q = session.createQuery(sql);
2516
2517 if (!pagination) {
2518 list = (List<MBStatsUser>)QueryUtil.list(q, getDialect(),
2519 start, end, false);
2520
2521 Collections.sort(list);
2522
2523 list = Collections.unmodifiableList(list);
2524 }
2525 else {
2526 list = (List<MBStatsUser>)QueryUtil.list(q, getDialect(),
2527 start, end);
2528 }
2529
2530 cacheResult(list);
2531
2532 finderCache.putResult(finderPath, finderArgs, list);
2533 }
2534 catch (Exception e) {
2535 finderCache.removeResult(finderPath, finderArgs);
2536
2537 throw processException(e);
2538 }
2539 finally {
2540 closeSession(session);
2541 }
2542 }
2543
2544 return list;
2545 }
2546
2547
2551 @Override
2552 public void removeAll() {
2553 for (MBStatsUser mbStatsUser : findAll()) {
2554 remove(mbStatsUser);
2555 }
2556 }
2557
2558
2563 @Override
2564 public int countAll() {
2565 Long count = (Long)finderCache.getResult(FINDER_PATH_COUNT_ALL,
2566 FINDER_ARGS_EMPTY, this);
2567
2568 if (count == null) {
2569 Session session = null;
2570
2571 try {
2572 session = openSession();
2573
2574 Query q = session.createQuery(_SQL_COUNT_MBSTATSUSER);
2575
2576 count = (Long)q.uniqueResult();
2577
2578 finderCache.putResult(FINDER_PATH_COUNT_ALL, FINDER_ARGS_EMPTY,
2579 count);
2580 }
2581 catch (Exception e) {
2582 finderCache.removeResult(FINDER_PATH_COUNT_ALL,
2583 FINDER_ARGS_EMPTY);
2584
2585 throw processException(e);
2586 }
2587 finally {
2588 closeSession(session);
2589 }
2590 }
2591
2592 return count.intValue();
2593 }
2594
2595 @Override
2596 protected Map<String, Integer> getTableColumnsMap() {
2597 return MBStatsUserModelImpl.TABLE_COLUMNS_MAP;
2598 }
2599
2600
2603 public void afterPropertiesSet() {
2604 }
2605
2606 public void destroy() {
2607 entityCache.removeCache(MBStatsUserImpl.class.getName());
2608 finderCache.removeCache(FINDER_CLASS_NAME_ENTITY);
2609 finderCache.removeCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
2610 finderCache.removeCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
2611 }
2612
2613 protected EntityCache entityCache = EntityCacheUtil.getEntityCache();
2614 protected FinderCache finderCache = FinderCacheUtil.getFinderCache();
2615 private static final String _SQL_SELECT_MBSTATSUSER = "SELECT mbStatsUser FROM MBStatsUser mbStatsUser";
2616 private static final String _SQL_SELECT_MBSTATSUSER_WHERE_PKS_IN = "SELECT mbStatsUser FROM MBStatsUser mbStatsUser WHERE statsUserId IN (";
2617 private static final String _SQL_SELECT_MBSTATSUSER_WHERE = "SELECT mbStatsUser FROM MBStatsUser mbStatsUser WHERE ";
2618 private static final String _SQL_COUNT_MBSTATSUSER = "SELECT COUNT(mbStatsUser) FROM MBStatsUser mbStatsUser";
2619 private static final String _SQL_COUNT_MBSTATSUSER_WHERE = "SELECT COUNT(mbStatsUser) FROM MBStatsUser mbStatsUser WHERE ";
2620 private static final String _ORDER_BY_ENTITY_ALIAS = "mbStatsUser.";
2621 private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No MBStatsUser exists with the primary key ";
2622 private static final String _NO_SUCH_ENTITY_WITH_KEY = "No MBStatsUser exists with the key {";
2623 private static final Log _log = LogFactoryUtil.getLog(MBStatsUserPersistenceImpl.class);
2624 private static final MBStatsUser _nullMBStatsUser = new MBStatsUserImpl() {
2625 @Override
2626 public Object clone() {
2627 return this;
2628 }
2629
2630 @Override
2631 public CacheModel<MBStatsUser> toCacheModel() {
2632 return _nullMBStatsUserCacheModel;
2633 }
2634 };
2635
2636 private static final CacheModel<MBStatsUser> _nullMBStatsUserCacheModel = new CacheModel<MBStatsUser>() {
2637 @Override
2638 public MBStatsUser toEntityModel() {
2639 return _nullMBStatsUser;
2640 }
2641 };
2642 }