001
014
015 package com.liferay.portlet.social.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.Session;
025 import com.liferay.portal.kernel.exception.SystemException;
026 import com.liferay.portal.kernel.log.Log;
027 import com.liferay.portal.kernel.log.LogFactoryUtil;
028 import com.liferay.portal.kernel.util.GetterUtil;
029 import com.liferay.portal.kernel.util.InstanceFactory;
030 import com.liferay.portal.kernel.util.OrderByComparator;
031 import com.liferay.portal.kernel.util.SetUtil;
032 import com.liferay.portal.kernel.util.StringBundler;
033 import com.liferay.portal.kernel.util.StringPool;
034 import com.liferay.portal.kernel.util.StringUtil;
035 import com.liferay.portal.kernel.util.UnmodifiableList;
036 import com.liferay.portal.kernel.util.Validator;
037 import com.liferay.portal.kernel.uuid.PortalUUIDUtil;
038 import com.liferay.portal.model.CacheModel;
039 import com.liferay.portal.model.ModelListener;
040 import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
041
042 import com.liferay.portlet.social.NoSuchRelationException;
043 import com.liferay.portlet.social.model.SocialRelation;
044 import com.liferay.portlet.social.model.impl.SocialRelationImpl;
045 import com.liferay.portlet.social.model.impl.SocialRelationModelImpl;
046
047 import java.io.Serializable;
048
049 import java.util.ArrayList;
050 import java.util.Collections;
051 import java.util.List;
052 import java.util.Set;
053
054
066 public class SocialRelationPersistenceImpl extends BasePersistenceImpl<SocialRelation>
067 implements SocialRelationPersistence {
068
073 public static final String FINDER_CLASS_NAME_ENTITY = SocialRelationImpl.class.getName();
074 public static final String FINDER_CLASS_NAME_LIST_WITH_PAGINATION = FINDER_CLASS_NAME_ENTITY +
075 ".List1";
076 public static final String FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION = FINDER_CLASS_NAME_ENTITY +
077 ".List2";
078 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_ALL = new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
079 SocialRelationModelImpl.FINDER_CACHE_ENABLED,
080 SocialRelationImpl.class, FINDER_CLASS_NAME_LIST_WITH_PAGINATION,
081 "findAll", new String[0]);
082 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL = new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
083 SocialRelationModelImpl.FINDER_CACHE_ENABLED,
084 SocialRelationImpl.class,
085 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findAll", new String[0]);
086 public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
087 SocialRelationModelImpl.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(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
090 SocialRelationModelImpl.FINDER_CACHE_ENABLED,
091 SocialRelationImpl.class, FINDER_CLASS_NAME_LIST_WITH_PAGINATION,
092 "findByUuid",
093 new String[] {
094 String.class.getName(),
095
096 Integer.class.getName(), Integer.class.getName(),
097 OrderByComparator.class.getName()
098 });
099 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID = new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
100 SocialRelationModelImpl.FINDER_CACHE_ENABLED,
101 SocialRelationImpl.class,
102 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByUuid",
103 new String[] { String.class.getName() },
104 SocialRelationModelImpl.UUID_COLUMN_BITMASK);
105 public static final FinderPath FINDER_PATH_COUNT_BY_UUID = new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
106 SocialRelationModelImpl.FINDER_CACHE_ENABLED, Long.class,
107 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByUuid",
108 new String[] { String.class.getName() });
109
110
117 @Override
118 public List<SocialRelation> findByUuid(String uuid)
119 throws SystemException {
120 return findByUuid(uuid, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
121 }
122
123
136 @Override
137 public List<SocialRelation> findByUuid(String uuid, int start, int end)
138 throws SystemException {
139 return findByUuid(uuid, start, end, null);
140 }
141
142
156 @Override
157 public List<SocialRelation> findByUuid(String uuid, int start, int end,
158 OrderByComparator orderByComparator) throws SystemException {
159 boolean pagination = true;
160 FinderPath finderPath = null;
161 Object[] finderArgs = null;
162
163 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
164 (orderByComparator == null)) {
165 pagination = false;
166 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID;
167 finderArgs = new Object[] { uuid };
168 }
169 else {
170 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_UUID;
171 finderArgs = new Object[] { uuid, start, end, orderByComparator };
172 }
173
174 List<SocialRelation> list = (List<SocialRelation>)FinderCacheUtil.getResult(finderPath,
175 finderArgs, this);
176
177 if ((list != null) && !list.isEmpty()) {
178 for (SocialRelation socialRelation : list) {
179 if (!Validator.equals(uuid, socialRelation.getUuid())) {
180 list = null;
181
182 break;
183 }
184 }
185 }
186
187 if (list == null) {
188 StringBundler query = null;
189
190 if (orderByComparator != null) {
191 query = new StringBundler(3 +
192 (orderByComparator.getOrderByFields().length * 3));
193 }
194 else {
195 query = new StringBundler(3);
196 }
197
198 query.append(_SQL_SELECT_SOCIALRELATION_WHERE);
199
200 boolean bindUuid = false;
201
202 if (uuid == null) {
203 query.append(_FINDER_COLUMN_UUID_UUID_1);
204 }
205 else if (uuid.equals(StringPool.BLANK)) {
206 query.append(_FINDER_COLUMN_UUID_UUID_3);
207 }
208 else {
209 bindUuid = true;
210
211 query.append(_FINDER_COLUMN_UUID_UUID_2);
212 }
213
214 if (orderByComparator != null) {
215 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
216 orderByComparator);
217 }
218 else
219 if (pagination) {
220 query.append(SocialRelationModelImpl.ORDER_BY_JPQL);
221 }
222
223 String sql = query.toString();
224
225 Session session = null;
226
227 try {
228 session = openSession();
229
230 Query q = session.createQuery(sql);
231
232 QueryPos qPos = QueryPos.getInstance(q);
233
234 if (bindUuid) {
235 qPos.add(uuid);
236 }
237
238 if (!pagination) {
239 list = (List<SocialRelation>)QueryUtil.list(q,
240 getDialect(), start, end, false);
241
242 Collections.sort(list);
243
244 list = new UnmodifiableList<SocialRelation>(list);
245 }
246 else {
247 list = (List<SocialRelation>)QueryUtil.list(q,
248 getDialect(), start, end);
249 }
250
251 cacheResult(list);
252
253 FinderCacheUtil.putResult(finderPath, finderArgs, list);
254 }
255 catch (Exception e) {
256 FinderCacheUtil.removeResult(finderPath, finderArgs);
257
258 throw processException(e);
259 }
260 finally {
261 closeSession(session);
262 }
263 }
264
265 return list;
266 }
267
268
277 @Override
278 public SocialRelation findByUuid_First(String uuid,
279 OrderByComparator orderByComparator)
280 throws NoSuchRelationException, SystemException {
281 SocialRelation socialRelation = fetchByUuid_First(uuid,
282 orderByComparator);
283
284 if (socialRelation != null) {
285 return socialRelation;
286 }
287
288 StringBundler msg = new StringBundler(4);
289
290 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
291
292 msg.append("uuid=");
293 msg.append(uuid);
294
295 msg.append(StringPool.CLOSE_CURLY_BRACE);
296
297 throw new NoSuchRelationException(msg.toString());
298 }
299
300
308 @Override
309 public SocialRelation fetchByUuid_First(String uuid,
310 OrderByComparator orderByComparator) throws SystemException {
311 List<SocialRelation> list = findByUuid(uuid, 0, 1, orderByComparator);
312
313 if (!list.isEmpty()) {
314 return list.get(0);
315 }
316
317 return null;
318 }
319
320
329 @Override
330 public SocialRelation findByUuid_Last(String uuid,
331 OrderByComparator orderByComparator)
332 throws NoSuchRelationException, SystemException {
333 SocialRelation socialRelation = fetchByUuid_Last(uuid, orderByComparator);
334
335 if (socialRelation != null) {
336 return socialRelation;
337 }
338
339 StringBundler msg = new StringBundler(4);
340
341 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
342
343 msg.append("uuid=");
344 msg.append(uuid);
345
346 msg.append(StringPool.CLOSE_CURLY_BRACE);
347
348 throw new NoSuchRelationException(msg.toString());
349 }
350
351
359 @Override
360 public SocialRelation fetchByUuid_Last(String uuid,
361 OrderByComparator orderByComparator) throws SystemException {
362 int count = countByUuid(uuid);
363
364 if (count == 0) {
365 return null;
366 }
367
368 List<SocialRelation> list = findByUuid(uuid, count - 1, count,
369 orderByComparator);
370
371 if (!list.isEmpty()) {
372 return list.get(0);
373 }
374
375 return null;
376 }
377
378
388 @Override
389 public SocialRelation[] findByUuid_PrevAndNext(long relationId,
390 String uuid, OrderByComparator orderByComparator)
391 throws NoSuchRelationException, SystemException {
392 SocialRelation socialRelation = findByPrimaryKey(relationId);
393
394 Session session = null;
395
396 try {
397 session = openSession();
398
399 SocialRelation[] array = new SocialRelationImpl[3];
400
401 array[0] = getByUuid_PrevAndNext(session, socialRelation, uuid,
402 orderByComparator, true);
403
404 array[1] = socialRelation;
405
406 array[2] = getByUuid_PrevAndNext(session, socialRelation, uuid,
407 orderByComparator, false);
408
409 return array;
410 }
411 catch (Exception e) {
412 throw processException(e);
413 }
414 finally {
415 closeSession(session);
416 }
417 }
418
419 protected SocialRelation getByUuid_PrevAndNext(Session session,
420 SocialRelation socialRelation, String uuid,
421 OrderByComparator orderByComparator, boolean previous) {
422 StringBundler query = null;
423
424 if (orderByComparator != null) {
425 query = new StringBundler(6 +
426 (orderByComparator.getOrderByFields().length * 6));
427 }
428 else {
429 query = new StringBundler(3);
430 }
431
432 query.append(_SQL_SELECT_SOCIALRELATION_WHERE);
433
434 boolean bindUuid = false;
435
436 if (uuid == null) {
437 query.append(_FINDER_COLUMN_UUID_UUID_1);
438 }
439 else if (uuid.equals(StringPool.BLANK)) {
440 query.append(_FINDER_COLUMN_UUID_UUID_3);
441 }
442 else {
443 bindUuid = true;
444
445 query.append(_FINDER_COLUMN_UUID_UUID_2);
446 }
447
448 if (orderByComparator != null) {
449 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
450
451 if (orderByConditionFields.length > 0) {
452 query.append(WHERE_AND);
453 }
454
455 for (int i = 0; i < orderByConditionFields.length; i++) {
456 query.append(_ORDER_BY_ENTITY_ALIAS);
457 query.append(orderByConditionFields[i]);
458
459 if ((i + 1) < orderByConditionFields.length) {
460 if (orderByComparator.isAscending() ^ previous) {
461 query.append(WHERE_GREATER_THAN_HAS_NEXT);
462 }
463 else {
464 query.append(WHERE_LESSER_THAN_HAS_NEXT);
465 }
466 }
467 else {
468 if (orderByComparator.isAscending() ^ previous) {
469 query.append(WHERE_GREATER_THAN);
470 }
471 else {
472 query.append(WHERE_LESSER_THAN);
473 }
474 }
475 }
476
477 query.append(ORDER_BY_CLAUSE);
478
479 String[] orderByFields = orderByComparator.getOrderByFields();
480
481 for (int i = 0; i < orderByFields.length; i++) {
482 query.append(_ORDER_BY_ENTITY_ALIAS);
483 query.append(orderByFields[i]);
484
485 if ((i + 1) < orderByFields.length) {
486 if (orderByComparator.isAscending() ^ previous) {
487 query.append(ORDER_BY_ASC_HAS_NEXT);
488 }
489 else {
490 query.append(ORDER_BY_DESC_HAS_NEXT);
491 }
492 }
493 else {
494 if (orderByComparator.isAscending() ^ previous) {
495 query.append(ORDER_BY_ASC);
496 }
497 else {
498 query.append(ORDER_BY_DESC);
499 }
500 }
501 }
502 }
503 else {
504 query.append(SocialRelationModelImpl.ORDER_BY_JPQL);
505 }
506
507 String sql = query.toString();
508
509 Query q = session.createQuery(sql);
510
511 q.setFirstResult(0);
512 q.setMaxResults(2);
513
514 QueryPos qPos = QueryPos.getInstance(q);
515
516 if (bindUuid) {
517 qPos.add(uuid);
518 }
519
520 if (orderByComparator != null) {
521 Object[] values = orderByComparator.getOrderByConditionValues(socialRelation);
522
523 for (Object value : values) {
524 qPos.add(value);
525 }
526 }
527
528 List<SocialRelation> list = q.list();
529
530 if (list.size() == 2) {
531 return list.get(1);
532 }
533 else {
534 return null;
535 }
536 }
537
538
544 @Override
545 public void removeByUuid(String uuid) throws SystemException {
546 for (SocialRelation socialRelation : findByUuid(uuid,
547 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
548 remove(socialRelation);
549 }
550 }
551
552
559 @Override
560 public int countByUuid(String uuid) throws SystemException {
561 FinderPath finderPath = FINDER_PATH_COUNT_BY_UUID;
562
563 Object[] finderArgs = new Object[] { uuid };
564
565 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
566 this);
567
568 if (count == null) {
569 StringBundler query = new StringBundler(2);
570
571 query.append(_SQL_COUNT_SOCIALRELATION_WHERE);
572
573 boolean bindUuid = false;
574
575 if (uuid == null) {
576 query.append(_FINDER_COLUMN_UUID_UUID_1);
577 }
578 else if (uuid.equals(StringPool.BLANK)) {
579 query.append(_FINDER_COLUMN_UUID_UUID_3);
580 }
581 else {
582 bindUuid = true;
583
584 query.append(_FINDER_COLUMN_UUID_UUID_2);
585 }
586
587 String sql = query.toString();
588
589 Session session = null;
590
591 try {
592 session = openSession();
593
594 Query q = session.createQuery(sql);
595
596 QueryPos qPos = QueryPos.getInstance(q);
597
598 if (bindUuid) {
599 qPos.add(uuid);
600 }
601
602 count = (Long)q.uniqueResult();
603
604 FinderCacheUtil.putResult(finderPath, finderArgs, count);
605 }
606 catch (Exception e) {
607 FinderCacheUtil.removeResult(finderPath, finderArgs);
608
609 throw processException(e);
610 }
611 finally {
612 closeSession(session);
613 }
614 }
615
616 return count.intValue();
617 }
618
619 private static final String _FINDER_COLUMN_UUID_UUID_1 = "socialRelation.uuid IS NULL";
620 private static final String _FINDER_COLUMN_UUID_UUID_2 = "socialRelation.uuid = ?";
621 private static final String _FINDER_COLUMN_UUID_UUID_3 = "(socialRelation.uuid IS NULL OR socialRelation.uuid = '')";
622 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_UUID_C = new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
623 SocialRelationModelImpl.FINDER_CACHE_ENABLED,
624 SocialRelationImpl.class, FINDER_CLASS_NAME_LIST_WITH_PAGINATION,
625 "findByUuid_C",
626 new String[] {
627 String.class.getName(), Long.class.getName(),
628
629 Integer.class.getName(), Integer.class.getName(),
630 OrderByComparator.class.getName()
631 });
632 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C =
633 new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
634 SocialRelationModelImpl.FINDER_CACHE_ENABLED,
635 SocialRelationImpl.class,
636 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByUuid_C",
637 new String[] { String.class.getName(), Long.class.getName() },
638 SocialRelationModelImpl.UUID_COLUMN_BITMASK |
639 SocialRelationModelImpl.COMPANYID_COLUMN_BITMASK);
640 public static final FinderPath FINDER_PATH_COUNT_BY_UUID_C = new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
641 SocialRelationModelImpl.FINDER_CACHE_ENABLED, Long.class,
642 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByUuid_C",
643 new String[] { String.class.getName(), Long.class.getName() });
644
645
653 @Override
654 public List<SocialRelation> findByUuid_C(String uuid, long companyId)
655 throws SystemException {
656 return findByUuid_C(uuid, companyId, QueryUtil.ALL_POS,
657 QueryUtil.ALL_POS, null);
658 }
659
660
674 @Override
675 public List<SocialRelation> findByUuid_C(String uuid, long companyId,
676 int start, int end) throws SystemException {
677 return findByUuid_C(uuid, companyId, start, end, null);
678 }
679
680
695 @Override
696 public List<SocialRelation> findByUuid_C(String uuid, long companyId,
697 int start, int end, OrderByComparator orderByComparator)
698 throws SystemException {
699 boolean pagination = true;
700 FinderPath finderPath = null;
701 Object[] finderArgs = null;
702
703 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
704 (orderByComparator == null)) {
705 pagination = false;
706 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C;
707 finderArgs = new Object[] { uuid, companyId };
708 }
709 else {
710 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_UUID_C;
711 finderArgs = new Object[] {
712 uuid, companyId,
713
714 start, end, orderByComparator
715 };
716 }
717
718 List<SocialRelation> list = (List<SocialRelation>)FinderCacheUtil.getResult(finderPath,
719 finderArgs, this);
720
721 if ((list != null) && !list.isEmpty()) {
722 for (SocialRelation socialRelation : list) {
723 if (!Validator.equals(uuid, socialRelation.getUuid()) ||
724 (companyId != socialRelation.getCompanyId())) {
725 list = null;
726
727 break;
728 }
729 }
730 }
731
732 if (list == null) {
733 StringBundler query = null;
734
735 if (orderByComparator != null) {
736 query = new StringBundler(4 +
737 (orderByComparator.getOrderByFields().length * 3));
738 }
739 else {
740 query = new StringBundler(4);
741 }
742
743 query.append(_SQL_SELECT_SOCIALRELATION_WHERE);
744
745 boolean bindUuid = false;
746
747 if (uuid == null) {
748 query.append(_FINDER_COLUMN_UUID_C_UUID_1);
749 }
750 else if (uuid.equals(StringPool.BLANK)) {
751 query.append(_FINDER_COLUMN_UUID_C_UUID_3);
752 }
753 else {
754 bindUuid = true;
755
756 query.append(_FINDER_COLUMN_UUID_C_UUID_2);
757 }
758
759 query.append(_FINDER_COLUMN_UUID_C_COMPANYID_2);
760
761 if (orderByComparator != null) {
762 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
763 orderByComparator);
764 }
765 else
766 if (pagination) {
767 query.append(SocialRelationModelImpl.ORDER_BY_JPQL);
768 }
769
770 String sql = query.toString();
771
772 Session session = null;
773
774 try {
775 session = openSession();
776
777 Query q = session.createQuery(sql);
778
779 QueryPos qPos = QueryPos.getInstance(q);
780
781 if (bindUuid) {
782 qPos.add(uuid);
783 }
784
785 qPos.add(companyId);
786
787 if (!pagination) {
788 list = (List<SocialRelation>)QueryUtil.list(q,
789 getDialect(), start, end, false);
790
791 Collections.sort(list);
792
793 list = new UnmodifiableList<SocialRelation>(list);
794 }
795 else {
796 list = (List<SocialRelation>)QueryUtil.list(q,
797 getDialect(), start, end);
798 }
799
800 cacheResult(list);
801
802 FinderCacheUtil.putResult(finderPath, finderArgs, list);
803 }
804 catch (Exception e) {
805 FinderCacheUtil.removeResult(finderPath, finderArgs);
806
807 throw processException(e);
808 }
809 finally {
810 closeSession(session);
811 }
812 }
813
814 return list;
815 }
816
817
827 @Override
828 public SocialRelation findByUuid_C_First(String uuid, long companyId,
829 OrderByComparator orderByComparator)
830 throws NoSuchRelationException, SystemException {
831 SocialRelation socialRelation = fetchByUuid_C_First(uuid, companyId,
832 orderByComparator);
833
834 if (socialRelation != null) {
835 return socialRelation;
836 }
837
838 StringBundler msg = new StringBundler(6);
839
840 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
841
842 msg.append("uuid=");
843 msg.append(uuid);
844
845 msg.append(", companyId=");
846 msg.append(companyId);
847
848 msg.append(StringPool.CLOSE_CURLY_BRACE);
849
850 throw new NoSuchRelationException(msg.toString());
851 }
852
853
862 @Override
863 public SocialRelation fetchByUuid_C_First(String uuid, long companyId,
864 OrderByComparator orderByComparator) throws SystemException {
865 List<SocialRelation> list = findByUuid_C(uuid, companyId, 0, 1,
866 orderByComparator);
867
868 if (!list.isEmpty()) {
869 return list.get(0);
870 }
871
872 return null;
873 }
874
875
885 @Override
886 public SocialRelation findByUuid_C_Last(String uuid, long companyId,
887 OrderByComparator orderByComparator)
888 throws NoSuchRelationException, SystemException {
889 SocialRelation socialRelation = fetchByUuid_C_Last(uuid, companyId,
890 orderByComparator);
891
892 if (socialRelation != null) {
893 return socialRelation;
894 }
895
896 StringBundler msg = new StringBundler(6);
897
898 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
899
900 msg.append("uuid=");
901 msg.append(uuid);
902
903 msg.append(", companyId=");
904 msg.append(companyId);
905
906 msg.append(StringPool.CLOSE_CURLY_BRACE);
907
908 throw new NoSuchRelationException(msg.toString());
909 }
910
911
920 @Override
921 public SocialRelation fetchByUuid_C_Last(String uuid, long companyId,
922 OrderByComparator orderByComparator) throws SystemException {
923 int count = countByUuid_C(uuid, companyId);
924
925 if (count == 0) {
926 return null;
927 }
928
929 List<SocialRelation> list = findByUuid_C(uuid, companyId, count - 1,
930 count, orderByComparator);
931
932 if (!list.isEmpty()) {
933 return list.get(0);
934 }
935
936 return null;
937 }
938
939
950 @Override
951 public SocialRelation[] findByUuid_C_PrevAndNext(long relationId,
952 String uuid, long companyId, OrderByComparator orderByComparator)
953 throws NoSuchRelationException, SystemException {
954 SocialRelation socialRelation = findByPrimaryKey(relationId);
955
956 Session session = null;
957
958 try {
959 session = openSession();
960
961 SocialRelation[] array = new SocialRelationImpl[3];
962
963 array[0] = getByUuid_C_PrevAndNext(session, socialRelation, uuid,
964 companyId, orderByComparator, true);
965
966 array[1] = socialRelation;
967
968 array[2] = getByUuid_C_PrevAndNext(session, socialRelation, uuid,
969 companyId, orderByComparator, false);
970
971 return array;
972 }
973 catch (Exception e) {
974 throw processException(e);
975 }
976 finally {
977 closeSession(session);
978 }
979 }
980
981 protected SocialRelation getByUuid_C_PrevAndNext(Session session,
982 SocialRelation socialRelation, String uuid, long companyId,
983 OrderByComparator orderByComparator, boolean previous) {
984 StringBundler query = null;
985
986 if (orderByComparator != null) {
987 query = new StringBundler(6 +
988 (orderByComparator.getOrderByFields().length * 6));
989 }
990 else {
991 query = new StringBundler(3);
992 }
993
994 query.append(_SQL_SELECT_SOCIALRELATION_WHERE);
995
996 boolean bindUuid = false;
997
998 if (uuid == null) {
999 query.append(_FINDER_COLUMN_UUID_C_UUID_1);
1000 }
1001 else if (uuid.equals(StringPool.BLANK)) {
1002 query.append(_FINDER_COLUMN_UUID_C_UUID_3);
1003 }
1004 else {
1005 bindUuid = true;
1006
1007 query.append(_FINDER_COLUMN_UUID_C_UUID_2);
1008 }
1009
1010 query.append(_FINDER_COLUMN_UUID_C_COMPANYID_2);
1011
1012 if (orderByComparator != null) {
1013 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
1014
1015 if (orderByConditionFields.length > 0) {
1016 query.append(WHERE_AND);
1017 }
1018
1019 for (int i = 0; i < orderByConditionFields.length; i++) {
1020 query.append(_ORDER_BY_ENTITY_ALIAS);
1021 query.append(orderByConditionFields[i]);
1022
1023 if ((i + 1) < orderByConditionFields.length) {
1024 if (orderByComparator.isAscending() ^ previous) {
1025 query.append(WHERE_GREATER_THAN_HAS_NEXT);
1026 }
1027 else {
1028 query.append(WHERE_LESSER_THAN_HAS_NEXT);
1029 }
1030 }
1031 else {
1032 if (orderByComparator.isAscending() ^ previous) {
1033 query.append(WHERE_GREATER_THAN);
1034 }
1035 else {
1036 query.append(WHERE_LESSER_THAN);
1037 }
1038 }
1039 }
1040
1041 query.append(ORDER_BY_CLAUSE);
1042
1043 String[] orderByFields = orderByComparator.getOrderByFields();
1044
1045 for (int i = 0; i < orderByFields.length; i++) {
1046 query.append(_ORDER_BY_ENTITY_ALIAS);
1047 query.append(orderByFields[i]);
1048
1049 if ((i + 1) < orderByFields.length) {
1050 if (orderByComparator.isAscending() ^ previous) {
1051 query.append(ORDER_BY_ASC_HAS_NEXT);
1052 }
1053 else {
1054 query.append(ORDER_BY_DESC_HAS_NEXT);
1055 }
1056 }
1057 else {
1058 if (orderByComparator.isAscending() ^ previous) {
1059 query.append(ORDER_BY_ASC);
1060 }
1061 else {
1062 query.append(ORDER_BY_DESC);
1063 }
1064 }
1065 }
1066 }
1067 else {
1068 query.append(SocialRelationModelImpl.ORDER_BY_JPQL);
1069 }
1070
1071 String sql = query.toString();
1072
1073 Query q = session.createQuery(sql);
1074
1075 q.setFirstResult(0);
1076 q.setMaxResults(2);
1077
1078 QueryPos qPos = QueryPos.getInstance(q);
1079
1080 if (bindUuid) {
1081 qPos.add(uuid);
1082 }
1083
1084 qPos.add(companyId);
1085
1086 if (orderByComparator != null) {
1087 Object[] values = orderByComparator.getOrderByConditionValues(socialRelation);
1088
1089 for (Object value : values) {
1090 qPos.add(value);
1091 }
1092 }
1093
1094 List<SocialRelation> list = q.list();
1095
1096 if (list.size() == 2) {
1097 return list.get(1);
1098 }
1099 else {
1100 return null;
1101 }
1102 }
1103
1104
1111 @Override
1112 public void removeByUuid_C(String uuid, long companyId)
1113 throws SystemException {
1114 for (SocialRelation socialRelation : findByUuid_C(uuid, companyId,
1115 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
1116 remove(socialRelation);
1117 }
1118 }
1119
1120
1128 @Override
1129 public int countByUuid_C(String uuid, long companyId)
1130 throws SystemException {
1131 FinderPath finderPath = FINDER_PATH_COUNT_BY_UUID_C;
1132
1133 Object[] finderArgs = new Object[] { uuid, companyId };
1134
1135 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
1136 this);
1137
1138 if (count == null) {
1139 StringBundler query = new StringBundler(3);
1140
1141 query.append(_SQL_COUNT_SOCIALRELATION_WHERE);
1142
1143 boolean bindUuid = false;
1144
1145 if (uuid == null) {
1146 query.append(_FINDER_COLUMN_UUID_C_UUID_1);
1147 }
1148 else if (uuid.equals(StringPool.BLANK)) {
1149 query.append(_FINDER_COLUMN_UUID_C_UUID_3);
1150 }
1151 else {
1152 bindUuid = true;
1153
1154 query.append(_FINDER_COLUMN_UUID_C_UUID_2);
1155 }
1156
1157 query.append(_FINDER_COLUMN_UUID_C_COMPANYID_2);
1158
1159 String sql = query.toString();
1160
1161 Session session = null;
1162
1163 try {
1164 session = openSession();
1165
1166 Query q = session.createQuery(sql);
1167
1168 QueryPos qPos = QueryPos.getInstance(q);
1169
1170 if (bindUuid) {
1171 qPos.add(uuid);
1172 }
1173
1174 qPos.add(companyId);
1175
1176 count = (Long)q.uniqueResult();
1177
1178 FinderCacheUtil.putResult(finderPath, finderArgs, count);
1179 }
1180 catch (Exception e) {
1181 FinderCacheUtil.removeResult(finderPath, finderArgs);
1182
1183 throw processException(e);
1184 }
1185 finally {
1186 closeSession(session);
1187 }
1188 }
1189
1190 return count.intValue();
1191 }
1192
1193 private static final String _FINDER_COLUMN_UUID_C_UUID_1 = "socialRelation.uuid IS NULL AND ";
1194 private static final String _FINDER_COLUMN_UUID_C_UUID_2 = "socialRelation.uuid = ? AND ";
1195 private static final String _FINDER_COLUMN_UUID_C_UUID_3 = "(socialRelation.uuid IS NULL OR socialRelation.uuid = '') AND ";
1196 private static final String _FINDER_COLUMN_UUID_C_COMPANYID_2 = "socialRelation.companyId = ?";
1197 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_COMPANYID =
1198 new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
1199 SocialRelationModelImpl.FINDER_CACHE_ENABLED,
1200 SocialRelationImpl.class, FINDER_CLASS_NAME_LIST_WITH_PAGINATION,
1201 "findByCompanyId",
1202 new String[] {
1203 Long.class.getName(),
1204
1205 Integer.class.getName(), Integer.class.getName(),
1206 OrderByComparator.class.getName()
1207 });
1208 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_COMPANYID =
1209 new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
1210 SocialRelationModelImpl.FINDER_CACHE_ENABLED,
1211 SocialRelationImpl.class,
1212 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByCompanyId",
1213 new String[] { Long.class.getName() },
1214 SocialRelationModelImpl.COMPANYID_COLUMN_BITMASK);
1215 public static final FinderPath FINDER_PATH_COUNT_BY_COMPANYID = new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
1216 SocialRelationModelImpl.FINDER_CACHE_ENABLED, Long.class,
1217 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByCompanyId",
1218 new String[] { Long.class.getName() });
1219
1220
1227 @Override
1228 public List<SocialRelation> findByCompanyId(long companyId)
1229 throws SystemException {
1230 return findByCompanyId(companyId, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
1231 null);
1232 }
1233
1234
1247 @Override
1248 public List<SocialRelation> findByCompanyId(long companyId, int start,
1249 int end) throws SystemException {
1250 return findByCompanyId(companyId, start, end, null);
1251 }
1252
1253
1267 @Override
1268 public List<SocialRelation> findByCompanyId(long companyId, int start,
1269 int end, OrderByComparator orderByComparator) throws SystemException {
1270 boolean pagination = true;
1271 FinderPath finderPath = null;
1272 Object[] finderArgs = null;
1273
1274 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
1275 (orderByComparator == null)) {
1276 pagination = false;
1277 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_COMPANYID;
1278 finderArgs = new Object[] { companyId };
1279 }
1280 else {
1281 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_COMPANYID;
1282 finderArgs = new Object[] { companyId, start, end, orderByComparator };
1283 }
1284
1285 List<SocialRelation> list = (List<SocialRelation>)FinderCacheUtil.getResult(finderPath,
1286 finderArgs, this);
1287
1288 if ((list != null) && !list.isEmpty()) {
1289 for (SocialRelation socialRelation : list) {
1290 if ((companyId != socialRelation.getCompanyId())) {
1291 list = null;
1292
1293 break;
1294 }
1295 }
1296 }
1297
1298 if (list == null) {
1299 StringBundler query = null;
1300
1301 if (orderByComparator != null) {
1302 query = new StringBundler(3 +
1303 (orderByComparator.getOrderByFields().length * 3));
1304 }
1305 else {
1306 query = new StringBundler(3);
1307 }
1308
1309 query.append(_SQL_SELECT_SOCIALRELATION_WHERE);
1310
1311 query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1312
1313 if (orderByComparator != null) {
1314 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1315 orderByComparator);
1316 }
1317 else
1318 if (pagination) {
1319 query.append(SocialRelationModelImpl.ORDER_BY_JPQL);
1320 }
1321
1322 String sql = query.toString();
1323
1324 Session session = null;
1325
1326 try {
1327 session = openSession();
1328
1329 Query q = session.createQuery(sql);
1330
1331 QueryPos qPos = QueryPos.getInstance(q);
1332
1333 qPos.add(companyId);
1334
1335 if (!pagination) {
1336 list = (List<SocialRelation>)QueryUtil.list(q,
1337 getDialect(), start, end, false);
1338
1339 Collections.sort(list);
1340
1341 list = new UnmodifiableList<SocialRelation>(list);
1342 }
1343 else {
1344 list = (List<SocialRelation>)QueryUtil.list(q,
1345 getDialect(), start, end);
1346 }
1347
1348 cacheResult(list);
1349
1350 FinderCacheUtil.putResult(finderPath, finderArgs, list);
1351 }
1352 catch (Exception e) {
1353 FinderCacheUtil.removeResult(finderPath, finderArgs);
1354
1355 throw processException(e);
1356 }
1357 finally {
1358 closeSession(session);
1359 }
1360 }
1361
1362 return list;
1363 }
1364
1365
1374 @Override
1375 public SocialRelation findByCompanyId_First(long companyId,
1376 OrderByComparator orderByComparator)
1377 throws NoSuchRelationException, SystemException {
1378 SocialRelation socialRelation = fetchByCompanyId_First(companyId,
1379 orderByComparator);
1380
1381 if (socialRelation != null) {
1382 return socialRelation;
1383 }
1384
1385 StringBundler msg = new StringBundler(4);
1386
1387 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1388
1389 msg.append("companyId=");
1390 msg.append(companyId);
1391
1392 msg.append(StringPool.CLOSE_CURLY_BRACE);
1393
1394 throw new NoSuchRelationException(msg.toString());
1395 }
1396
1397
1405 @Override
1406 public SocialRelation fetchByCompanyId_First(long companyId,
1407 OrderByComparator orderByComparator) throws SystemException {
1408 List<SocialRelation> list = findByCompanyId(companyId, 0, 1,
1409 orderByComparator);
1410
1411 if (!list.isEmpty()) {
1412 return list.get(0);
1413 }
1414
1415 return null;
1416 }
1417
1418
1427 @Override
1428 public SocialRelation findByCompanyId_Last(long companyId,
1429 OrderByComparator orderByComparator)
1430 throws NoSuchRelationException, SystemException {
1431 SocialRelation socialRelation = fetchByCompanyId_Last(companyId,
1432 orderByComparator);
1433
1434 if (socialRelation != null) {
1435 return socialRelation;
1436 }
1437
1438 StringBundler msg = new StringBundler(4);
1439
1440 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1441
1442 msg.append("companyId=");
1443 msg.append(companyId);
1444
1445 msg.append(StringPool.CLOSE_CURLY_BRACE);
1446
1447 throw new NoSuchRelationException(msg.toString());
1448 }
1449
1450
1458 @Override
1459 public SocialRelation fetchByCompanyId_Last(long companyId,
1460 OrderByComparator orderByComparator) throws SystemException {
1461 int count = countByCompanyId(companyId);
1462
1463 if (count == 0) {
1464 return null;
1465 }
1466
1467 List<SocialRelation> list = findByCompanyId(companyId, count - 1,
1468 count, orderByComparator);
1469
1470 if (!list.isEmpty()) {
1471 return list.get(0);
1472 }
1473
1474 return null;
1475 }
1476
1477
1487 @Override
1488 public SocialRelation[] findByCompanyId_PrevAndNext(long relationId,
1489 long companyId, OrderByComparator orderByComparator)
1490 throws NoSuchRelationException, SystemException {
1491 SocialRelation socialRelation = findByPrimaryKey(relationId);
1492
1493 Session session = null;
1494
1495 try {
1496 session = openSession();
1497
1498 SocialRelation[] array = new SocialRelationImpl[3];
1499
1500 array[0] = getByCompanyId_PrevAndNext(session, socialRelation,
1501 companyId, orderByComparator, true);
1502
1503 array[1] = socialRelation;
1504
1505 array[2] = getByCompanyId_PrevAndNext(session, socialRelation,
1506 companyId, orderByComparator, false);
1507
1508 return array;
1509 }
1510 catch (Exception e) {
1511 throw processException(e);
1512 }
1513 finally {
1514 closeSession(session);
1515 }
1516 }
1517
1518 protected SocialRelation getByCompanyId_PrevAndNext(Session session,
1519 SocialRelation socialRelation, long companyId,
1520 OrderByComparator orderByComparator, boolean previous) {
1521 StringBundler query = null;
1522
1523 if (orderByComparator != null) {
1524 query = new StringBundler(6 +
1525 (orderByComparator.getOrderByFields().length * 6));
1526 }
1527 else {
1528 query = new StringBundler(3);
1529 }
1530
1531 query.append(_SQL_SELECT_SOCIALRELATION_WHERE);
1532
1533 query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1534
1535 if (orderByComparator != null) {
1536 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
1537
1538 if (orderByConditionFields.length > 0) {
1539 query.append(WHERE_AND);
1540 }
1541
1542 for (int i = 0; i < orderByConditionFields.length; i++) {
1543 query.append(_ORDER_BY_ENTITY_ALIAS);
1544 query.append(orderByConditionFields[i]);
1545
1546 if ((i + 1) < orderByConditionFields.length) {
1547 if (orderByComparator.isAscending() ^ previous) {
1548 query.append(WHERE_GREATER_THAN_HAS_NEXT);
1549 }
1550 else {
1551 query.append(WHERE_LESSER_THAN_HAS_NEXT);
1552 }
1553 }
1554 else {
1555 if (orderByComparator.isAscending() ^ previous) {
1556 query.append(WHERE_GREATER_THAN);
1557 }
1558 else {
1559 query.append(WHERE_LESSER_THAN);
1560 }
1561 }
1562 }
1563
1564 query.append(ORDER_BY_CLAUSE);
1565
1566 String[] orderByFields = orderByComparator.getOrderByFields();
1567
1568 for (int i = 0; i < orderByFields.length; i++) {
1569 query.append(_ORDER_BY_ENTITY_ALIAS);
1570 query.append(orderByFields[i]);
1571
1572 if ((i + 1) < orderByFields.length) {
1573 if (orderByComparator.isAscending() ^ previous) {
1574 query.append(ORDER_BY_ASC_HAS_NEXT);
1575 }
1576 else {
1577 query.append(ORDER_BY_DESC_HAS_NEXT);
1578 }
1579 }
1580 else {
1581 if (orderByComparator.isAscending() ^ previous) {
1582 query.append(ORDER_BY_ASC);
1583 }
1584 else {
1585 query.append(ORDER_BY_DESC);
1586 }
1587 }
1588 }
1589 }
1590 else {
1591 query.append(SocialRelationModelImpl.ORDER_BY_JPQL);
1592 }
1593
1594 String sql = query.toString();
1595
1596 Query q = session.createQuery(sql);
1597
1598 q.setFirstResult(0);
1599 q.setMaxResults(2);
1600
1601 QueryPos qPos = QueryPos.getInstance(q);
1602
1603 qPos.add(companyId);
1604
1605 if (orderByComparator != null) {
1606 Object[] values = orderByComparator.getOrderByConditionValues(socialRelation);
1607
1608 for (Object value : values) {
1609 qPos.add(value);
1610 }
1611 }
1612
1613 List<SocialRelation> list = q.list();
1614
1615 if (list.size() == 2) {
1616 return list.get(1);
1617 }
1618 else {
1619 return null;
1620 }
1621 }
1622
1623
1629 @Override
1630 public void removeByCompanyId(long companyId) throws SystemException {
1631 for (SocialRelation socialRelation : findByCompanyId(companyId,
1632 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
1633 remove(socialRelation);
1634 }
1635 }
1636
1637
1644 @Override
1645 public int countByCompanyId(long companyId) throws SystemException {
1646 FinderPath finderPath = FINDER_PATH_COUNT_BY_COMPANYID;
1647
1648 Object[] finderArgs = new Object[] { companyId };
1649
1650 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
1651 this);
1652
1653 if (count == null) {
1654 StringBundler query = new StringBundler(2);
1655
1656 query.append(_SQL_COUNT_SOCIALRELATION_WHERE);
1657
1658 query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1659
1660 String sql = query.toString();
1661
1662 Session session = null;
1663
1664 try {
1665 session = openSession();
1666
1667 Query q = session.createQuery(sql);
1668
1669 QueryPos qPos = QueryPos.getInstance(q);
1670
1671 qPos.add(companyId);
1672
1673 count = (Long)q.uniqueResult();
1674
1675 FinderCacheUtil.putResult(finderPath, finderArgs, count);
1676 }
1677 catch (Exception e) {
1678 FinderCacheUtil.removeResult(finderPath, finderArgs);
1679
1680 throw processException(e);
1681 }
1682 finally {
1683 closeSession(session);
1684 }
1685 }
1686
1687 return count.intValue();
1688 }
1689
1690 private static final String _FINDER_COLUMN_COMPANYID_COMPANYID_2 = "socialRelation.companyId = ?";
1691 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_USERID1 = new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
1692 SocialRelationModelImpl.FINDER_CACHE_ENABLED,
1693 SocialRelationImpl.class, FINDER_CLASS_NAME_LIST_WITH_PAGINATION,
1694 "findByUserId1",
1695 new String[] {
1696 Long.class.getName(),
1697
1698 Integer.class.getName(), Integer.class.getName(),
1699 OrderByComparator.class.getName()
1700 });
1701 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_USERID1 =
1702 new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
1703 SocialRelationModelImpl.FINDER_CACHE_ENABLED,
1704 SocialRelationImpl.class,
1705 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByUserId1",
1706 new String[] { Long.class.getName() },
1707 SocialRelationModelImpl.USERID1_COLUMN_BITMASK);
1708 public static final FinderPath FINDER_PATH_COUNT_BY_USERID1 = new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
1709 SocialRelationModelImpl.FINDER_CACHE_ENABLED, Long.class,
1710 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByUserId1",
1711 new String[] { Long.class.getName() });
1712
1713
1720 @Override
1721 public List<SocialRelation> findByUserId1(long userId1)
1722 throws SystemException {
1723 return findByUserId1(userId1, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1724 }
1725
1726
1739 @Override
1740 public List<SocialRelation> findByUserId1(long userId1, int start, int end)
1741 throws SystemException {
1742 return findByUserId1(userId1, start, end, null);
1743 }
1744
1745
1759 @Override
1760 public List<SocialRelation> findByUserId1(long userId1, int start, int end,
1761 OrderByComparator orderByComparator) throws SystemException {
1762 boolean pagination = true;
1763 FinderPath finderPath = null;
1764 Object[] finderArgs = null;
1765
1766 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
1767 (orderByComparator == null)) {
1768 pagination = false;
1769 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_USERID1;
1770 finderArgs = new Object[] { userId1 };
1771 }
1772 else {
1773 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_USERID1;
1774 finderArgs = new Object[] { userId1, start, end, orderByComparator };
1775 }
1776
1777 List<SocialRelation> list = (List<SocialRelation>)FinderCacheUtil.getResult(finderPath,
1778 finderArgs, this);
1779
1780 if ((list != null) && !list.isEmpty()) {
1781 for (SocialRelation socialRelation : list) {
1782 if ((userId1 != socialRelation.getUserId1())) {
1783 list = null;
1784
1785 break;
1786 }
1787 }
1788 }
1789
1790 if (list == null) {
1791 StringBundler query = null;
1792
1793 if (orderByComparator != null) {
1794 query = new StringBundler(3 +
1795 (orderByComparator.getOrderByFields().length * 3));
1796 }
1797 else {
1798 query = new StringBundler(3);
1799 }
1800
1801 query.append(_SQL_SELECT_SOCIALRELATION_WHERE);
1802
1803 query.append(_FINDER_COLUMN_USERID1_USERID1_2);
1804
1805 if (orderByComparator != null) {
1806 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1807 orderByComparator);
1808 }
1809 else
1810 if (pagination) {
1811 query.append(SocialRelationModelImpl.ORDER_BY_JPQL);
1812 }
1813
1814 String sql = query.toString();
1815
1816 Session session = null;
1817
1818 try {
1819 session = openSession();
1820
1821 Query q = session.createQuery(sql);
1822
1823 QueryPos qPos = QueryPos.getInstance(q);
1824
1825 qPos.add(userId1);
1826
1827 if (!pagination) {
1828 list = (List<SocialRelation>)QueryUtil.list(q,
1829 getDialect(), start, end, false);
1830
1831 Collections.sort(list);
1832
1833 list = new UnmodifiableList<SocialRelation>(list);
1834 }
1835 else {
1836 list = (List<SocialRelation>)QueryUtil.list(q,
1837 getDialect(), start, end);
1838 }
1839
1840 cacheResult(list);
1841
1842 FinderCacheUtil.putResult(finderPath, finderArgs, list);
1843 }
1844 catch (Exception e) {
1845 FinderCacheUtil.removeResult(finderPath, finderArgs);
1846
1847 throw processException(e);
1848 }
1849 finally {
1850 closeSession(session);
1851 }
1852 }
1853
1854 return list;
1855 }
1856
1857
1866 @Override
1867 public SocialRelation findByUserId1_First(long userId1,
1868 OrderByComparator orderByComparator)
1869 throws NoSuchRelationException, SystemException {
1870 SocialRelation socialRelation = fetchByUserId1_First(userId1,
1871 orderByComparator);
1872
1873 if (socialRelation != null) {
1874 return socialRelation;
1875 }
1876
1877 StringBundler msg = new StringBundler(4);
1878
1879 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1880
1881 msg.append("userId1=");
1882 msg.append(userId1);
1883
1884 msg.append(StringPool.CLOSE_CURLY_BRACE);
1885
1886 throw new NoSuchRelationException(msg.toString());
1887 }
1888
1889
1897 @Override
1898 public SocialRelation fetchByUserId1_First(long userId1,
1899 OrderByComparator orderByComparator) throws SystemException {
1900 List<SocialRelation> list = findByUserId1(userId1, 0, 1,
1901 orderByComparator);
1902
1903 if (!list.isEmpty()) {
1904 return list.get(0);
1905 }
1906
1907 return null;
1908 }
1909
1910
1919 @Override
1920 public SocialRelation findByUserId1_Last(long userId1,
1921 OrderByComparator orderByComparator)
1922 throws NoSuchRelationException, SystemException {
1923 SocialRelation socialRelation = fetchByUserId1_Last(userId1,
1924 orderByComparator);
1925
1926 if (socialRelation != null) {
1927 return socialRelation;
1928 }
1929
1930 StringBundler msg = new StringBundler(4);
1931
1932 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1933
1934 msg.append("userId1=");
1935 msg.append(userId1);
1936
1937 msg.append(StringPool.CLOSE_CURLY_BRACE);
1938
1939 throw new NoSuchRelationException(msg.toString());
1940 }
1941
1942
1950 @Override
1951 public SocialRelation fetchByUserId1_Last(long userId1,
1952 OrderByComparator orderByComparator) throws SystemException {
1953 int count = countByUserId1(userId1);
1954
1955 if (count == 0) {
1956 return null;
1957 }
1958
1959 List<SocialRelation> list = findByUserId1(userId1, count - 1, count,
1960 orderByComparator);
1961
1962 if (!list.isEmpty()) {
1963 return list.get(0);
1964 }
1965
1966 return null;
1967 }
1968
1969
1979 @Override
1980 public SocialRelation[] findByUserId1_PrevAndNext(long relationId,
1981 long userId1, OrderByComparator orderByComparator)
1982 throws NoSuchRelationException, SystemException {
1983 SocialRelation socialRelation = findByPrimaryKey(relationId);
1984
1985 Session session = null;
1986
1987 try {
1988 session = openSession();
1989
1990 SocialRelation[] array = new SocialRelationImpl[3];
1991
1992 array[0] = getByUserId1_PrevAndNext(session, socialRelation,
1993 userId1, orderByComparator, true);
1994
1995 array[1] = socialRelation;
1996
1997 array[2] = getByUserId1_PrevAndNext(session, socialRelation,
1998 userId1, orderByComparator, false);
1999
2000 return array;
2001 }
2002 catch (Exception e) {
2003 throw processException(e);
2004 }
2005 finally {
2006 closeSession(session);
2007 }
2008 }
2009
2010 protected SocialRelation getByUserId1_PrevAndNext(Session session,
2011 SocialRelation socialRelation, long userId1,
2012 OrderByComparator orderByComparator, boolean previous) {
2013 StringBundler query = null;
2014
2015 if (orderByComparator != null) {
2016 query = new StringBundler(6 +
2017 (orderByComparator.getOrderByFields().length * 6));
2018 }
2019 else {
2020 query = new StringBundler(3);
2021 }
2022
2023 query.append(_SQL_SELECT_SOCIALRELATION_WHERE);
2024
2025 query.append(_FINDER_COLUMN_USERID1_USERID1_2);
2026
2027 if (orderByComparator != null) {
2028 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
2029
2030 if (orderByConditionFields.length > 0) {
2031 query.append(WHERE_AND);
2032 }
2033
2034 for (int i = 0; i < orderByConditionFields.length; i++) {
2035 query.append(_ORDER_BY_ENTITY_ALIAS);
2036 query.append(orderByConditionFields[i]);
2037
2038 if ((i + 1) < orderByConditionFields.length) {
2039 if (orderByComparator.isAscending() ^ previous) {
2040 query.append(WHERE_GREATER_THAN_HAS_NEXT);
2041 }
2042 else {
2043 query.append(WHERE_LESSER_THAN_HAS_NEXT);
2044 }
2045 }
2046 else {
2047 if (orderByComparator.isAscending() ^ previous) {
2048 query.append(WHERE_GREATER_THAN);
2049 }
2050 else {
2051 query.append(WHERE_LESSER_THAN);
2052 }
2053 }
2054 }
2055
2056 query.append(ORDER_BY_CLAUSE);
2057
2058 String[] orderByFields = orderByComparator.getOrderByFields();
2059
2060 for (int i = 0; i < orderByFields.length; i++) {
2061 query.append(_ORDER_BY_ENTITY_ALIAS);
2062 query.append(orderByFields[i]);
2063
2064 if ((i + 1) < orderByFields.length) {
2065 if (orderByComparator.isAscending() ^ previous) {
2066 query.append(ORDER_BY_ASC_HAS_NEXT);
2067 }
2068 else {
2069 query.append(ORDER_BY_DESC_HAS_NEXT);
2070 }
2071 }
2072 else {
2073 if (orderByComparator.isAscending() ^ previous) {
2074 query.append(ORDER_BY_ASC);
2075 }
2076 else {
2077 query.append(ORDER_BY_DESC);
2078 }
2079 }
2080 }
2081 }
2082 else {
2083 query.append(SocialRelationModelImpl.ORDER_BY_JPQL);
2084 }
2085
2086 String sql = query.toString();
2087
2088 Query q = session.createQuery(sql);
2089
2090 q.setFirstResult(0);
2091 q.setMaxResults(2);
2092
2093 QueryPos qPos = QueryPos.getInstance(q);
2094
2095 qPos.add(userId1);
2096
2097 if (orderByComparator != null) {
2098 Object[] values = orderByComparator.getOrderByConditionValues(socialRelation);
2099
2100 for (Object value : values) {
2101 qPos.add(value);
2102 }
2103 }
2104
2105 List<SocialRelation> list = q.list();
2106
2107 if (list.size() == 2) {
2108 return list.get(1);
2109 }
2110 else {
2111 return null;
2112 }
2113 }
2114
2115
2121 @Override
2122 public void removeByUserId1(long userId1) throws SystemException {
2123 for (SocialRelation socialRelation : findByUserId1(userId1,
2124 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
2125 remove(socialRelation);
2126 }
2127 }
2128
2129
2136 @Override
2137 public int countByUserId1(long userId1) throws SystemException {
2138 FinderPath finderPath = FINDER_PATH_COUNT_BY_USERID1;
2139
2140 Object[] finderArgs = new Object[] { userId1 };
2141
2142 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
2143 this);
2144
2145 if (count == null) {
2146 StringBundler query = new StringBundler(2);
2147
2148 query.append(_SQL_COUNT_SOCIALRELATION_WHERE);
2149
2150 query.append(_FINDER_COLUMN_USERID1_USERID1_2);
2151
2152 String sql = query.toString();
2153
2154 Session session = null;
2155
2156 try {
2157 session = openSession();
2158
2159 Query q = session.createQuery(sql);
2160
2161 QueryPos qPos = QueryPos.getInstance(q);
2162
2163 qPos.add(userId1);
2164
2165 count = (Long)q.uniqueResult();
2166
2167 FinderCacheUtil.putResult(finderPath, finderArgs, count);
2168 }
2169 catch (Exception e) {
2170 FinderCacheUtil.removeResult(finderPath, finderArgs);
2171
2172 throw processException(e);
2173 }
2174 finally {
2175 closeSession(session);
2176 }
2177 }
2178
2179 return count.intValue();
2180 }
2181
2182 private static final String _FINDER_COLUMN_USERID1_USERID1_2 = "socialRelation.userId1 = ?";
2183 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_USERID2 = new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
2184 SocialRelationModelImpl.FINDER_CACHE_ENABLED,
2185 SocialRelationImpl.class, FINDER_CLASS_NAME_LIST_WITH_PAGINATION,
2186 "findByUserId2",
2187 new String[] {
2188 Long.class.getName(),
2189
2190 Integer.class.getName(), Integer.class.getName(),
2191 OrderByComparator.class.getName()
2192 });
2193 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_USERID2 =
2194 new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
2195 SocialRelationModelImpl.FINDER_CACHE_ENABLED,
2196 SocialRelationImpl.class,
2197 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByUserId2",
2198 new String[] { Long.class.getName() },
2199 SocialRelationModelImpl.USERID2_COLUMN_BITMASK);
2200 public static final FinderPath FINDER_PATH_COUNT_BY_USERID2 = new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
2201 SocialRelationModelImpl.FINDER_CACHE_ENABLED, Long.class,
2202 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByUserId2",
2203 new String[] { Long.class.getName() });
2204
2205
2212 @Override
2213 public List<SocialRelation> findByUserId2(long userId2)
2214 throws SystemException {
2215 return findByUserId2(userId2, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
2216 }
2217
2218
2231 @Override
2232 public List<SocialRelation> findByUserId2(long userId2, int start, int end)
2233 throws SystemException {
2234 return findByUserId2(userId2, start, end, null);
2235 }
2236
2237
2251 @Override
2252 public List<SocialRelation> findByUserId2(long userId2, int start, int end,
2253 OrderByComparator orderByComparator) throws SystemException {
2254 boolean pagination = true;
2255 FinderPath finderPath = null;
2256 Object[] finderArgs = null;
2257
2258 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
2259 (orderByComparator == null)) {
2260 pagination = false;
2261 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_USERID2;
2262 finderArgs = new Object[] { userId2 };
2263 }
2264 else {
2265 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_USERID2;
2266 finderArgs = new Object[] { userId2, start, end, orderByComparator };
2267 }
2268
2269 List<SocialRelation> list = (List<SocialRelation>)FinderCacheUtil.getResult(finderPath,
2270 finderArgs, this);
2271
2272 if ((list != null) && !list.isEmpty()) {
2273 for (SocialRelation socialRelation : list) {
2274 if ((userId2 != socialRelation.getUserId2())) {
2275 list = null;
2276
2277 break;
2278 }
2279 }
2280 }
2281
2282 if (list == null) {
2283 StringBundler query = null;
2284
2285 if (orderByComparator != null) {
2286 query = new StringBundler(3 +
2287 (orderByComparator.getOrderByFields().length * 3));
2288 }
2289 else {
2290 query = new StringBundler(3);
2291 }
2292
2293 query.append(_SQL_SELECT_SOCIALRELATION_WHERE);
2294
2295 query.append(_FINDER_COLUMN_USERID2_USERID2_2);
2296
2297 if (orderByComparator != null) {
2298 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2299 orderByComparator);
2300 }
2301 else
2302 if (pagination) {
2303 query.append(SocialRelationModelImpl.ORDER_BY_JPQL);
2304 }
2305
2306 String sql = query.toString();
2307
2308 Session session = null;
2309
2310 try {
2311 session = openSession();
2312
2313 Query q = session.createQuery(sql);
2314
2315 QueryPos qPos = QueryPos.getInstance(q);
2316
2317 qPos.add(userId2);
2318
2319 if (!pagination) {
2320 list = (List<SocialRelation>)QueryUtil.list(q,
2321 getDialect(), start, end, false);
2322
2323 Collections.sort(list);
2324
2325 list = new UnmodifiableList<SocialRelation>(list);
2326 }
2327 else {
2328 list = (List<SocialRelation>)QueryUtil.list(q,
2329 getDialect(), start, end);
2330 }
2331
2332 cacheResult(list);
2333
2334 FinderCacheUtil.putResult(finderPath, finderArgs, list);
2335 }
2336 catch (Exception e) {
2337 FinderCacheUtil.removeResult(finderPath, finderArgs);
2338
2339 throw processException(e);
2340 }
2341 finally {
2342 closeSession(session);
2343 }
2344 }
2345
2346 return list;
2347 }
2348
2349
2358 @Override
2359 public SocialRelation findByUserId2_First(long userId2,
2360 OrderByComparator orderByComparator)
2361 throws NoSuchRelationException, SystemException {
2362 SocialRelation socialRelation = fetchByUserId2_First(userId2,
2363 orderByComparator);
2364
2365 if (socialRelation != null) {
2366 return socialRelation;
2367 }
2368
2369 StringBundler msg = new StringBundler(4);
2370
2371 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2372
2373 msg.append("userId2=");
2374 msg.append(userId2);
2375
2376 msg.append(StringPool.CLOSE_CURLY_BRACE);
2377
2378 throw new NoSuchRelationException(msg.toString());
2379 }
2380
2381
2389 @Override
2390 public SocialRelation fetchByUserId2_First(long userId2,
2391 OrderByComparator orderByComparator) throws SystemException {
2392 List<SocialRelation> list = findByUserId2(userId2, 0, 1,
2393 orderByComparator);
2394
2395 if (!list.isEmpty()) {
2396 return list.get(0);
2397 }
2398
2399 return null;
2400 }
2401
2402
2411 @Override
2412 public SocialRelation findByUserId2_Last(long userId2,
2413 OrderByComparator orderByComparator)
2414 throws NoSuchRelationException, SystemException {
2415 SocialRelation socialRelation = fetchByUserId2_Last(userId2,
2416 orderByComparator);
2417
2418 if (socialRelation != null) {
2419 return socialRelation;
2420 }
2421
2422 StringBundler msg = new StringBundler(4);
2423
2424 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2425
2426 msg.append("userId2=");
2427 msg.append(userId2);
2428
2429 msg.append(StringPool.CLOSE_CURLY_BRACE);
2430
2431 throw new NoSuchRelationException(msg.toString());
2432 }
2433
2434
2442 @Override
2443 public SocialRelation fetchByUserId2_Last(long userId2,
2444 OrderByComparator orderByComparator) throws SystemException {
2445 int count = countByUserId2(userId2);
2446
2447 if (count == 0) {
2448 return null;
2449 }
2450
2451 List<SocialRelation> list = findByUserId2(userId2, count - 1, count,
2452 orderByComparator);
2453
2454 if (!list.isEmpty()) {
2455 return list.get(0);
2456 }
2457
2458 return null;
2459 }
2460
2461
2471 @Override
2472 public SocialRelation[] findByUserId2_PrevAndNext(long relationId,
2473 long userId2, OrderByComparator orderByComparator)
2474 throws NoSuchRelationException, SystemException {
2475 SocialRelation socialRelation = findByPrimaryKey(relationId);
2476
2477 Session session = null;
2478
2479 try {
2480 session = openSession();
2481
2482 SocialRelation[] array = new SocialRelationImpl[3];
2483
2484 array[0] = getByUserId2_PrevAndNext(session, socialRelation,
2485 userId2, orderByComparator, true);
2486
2487 array[1] = socialRelation;
2488
2489 array[2] = getByUserId2_PrevAndNext(session, socialRelation,
2490 userId2, orderByComparator, false);
2491
2492 return array;
2493 }
2494 catch (Exception e) {
2495 throw processException(e);
2496 }
2497 finally {
2498 closeSession(session);
2499 }
2500 }
2501
2502 protected SocialRelation getByUserId2_PrevAndNext(Session session,
2503 SocialRelation socialRelation, long userId2,
2504 OrderByComparator orderByComparator, boolean previous) {
2505 StringBundler query = null;
2506
2507 if (orderByComparator != null) {
2508 query = new StringBundler(6 +
2509 (orderByComparator.getOrderByFields().length * 6));
2510 }
2511 else {
2512 query = new StringBundler(3);
2513 }
2514
2515 query.append(_SQL_SELECT_SOCIALRELATION_WHERE);
2516
2517 query.append(_FINDER_COLUMN_USERID2_USERID2_2);
2518
2519 if (orderByComparator != null) {
2520 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
2521
2522 if (orderByConditionFields.length > 0) {
2523 query.append(WHERE_AND);
2524 }
2525
2526 for (int i = 0; i < orderByConditionFields.length; i++) {
2527 query.append(_ORDER_BY_ENTITY_ALIAS);
2528 query.append(orderByConditionFields[i]);
2529
2530 if ((i + 1) < orderByConditionFields.length) {
2531 if (orderByComparator.isAscending() ^ previous) {
2532 query.append(WHERE_GREATER_THAN_HAS_NEXT);
2533 }
2534 else {
2535 query.append(WHERE_LESSER_THAN_HAS_NEXT);
2536 }
2537 }
2538 else {
2539 if (orderByComparator.isAscending() ^ previous) {
2540 query.append(WHERE_GREATER_THAN);
2541 }
2542 else {
2543 query.append(WHERE_LESSER_THAN);
2544 }
2545 }
2546 }
2547
2548 query.append(ORDER_BY_CLAUSE);
2549
2550 String[] orderByFields = orderByComparator.getOrderByFields();
2551
2552 for (int i = 0; i < orderByFields.length; i++) {
2553 query.append(_ORDER_BY_ENTITY_ALIAS);
2554 query.append(orderByFields[i]);
2555
2556 if ((i + 1) < orderByFields.length) {
2557 if (orderByComparator.isAscending() ^ previous) {
2558 query.append(ORDER_BY_ASC_HAS_NEXT);
2559 }
2560 else {
2561 query.append(ORDER_BY_DESC_HAS_NEXT);
2562 }
2563 }
2564 else {
2565 if (orderByComparator.isAscending() ^ previous) {
2566 query.append(ORDER_BY_ASC);
2567 }
2568 else {
2569 query.append(ORDER_BY_DESC);
2570 }
2571 }
2572 }
2573 }
2574 else {
2575 query.append(SocialRelationModelImpl.ORDER_BY_JPQL);
2576 }
2577
2578 String sql = query.toString();
2579
2580 Query q = session.createQuery(sql);
2581
2582 q.setFirstResult(0);
2583 q.setMaxResults(2);
2584
2585 QueryPos qPos = QueryPos.getInstance(q);
2586
2587 qPos.add(userId2);
2588
2589 if (orderByComparator != null) {
2590 Object[] values = orderByComparator.getOrderByConditionValues(socialRelation);
2591
2592 for (Object value : values) {
2593 qPos.add(value);
2594 }
2595 }
2596
2597 List<SocialRelation> list = q.list();
2598
2599 if (list.size() == 2) {
2600 return list.get(1);
2601 }
2602 else {
2603 return null;
2604 }
2605 }
2606
2607
2613 @Override
2614 public void removeByUserId2(long userId2) throws SystemException {
2615 for (SocialRelation socialRelation : findByUserId2(userId2,
2616 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
2617 remove(socialRelation);
2618 }
2619 }
2620
2621
2628 @Override
2629 public int countByUserId2(long userId2) throws SystemException {
2630 FinderPath finderPath = FINDER_PATH_COUNT_BY_USERID2;
2631
2632 Object[] finderArgs = new Object[] { userId2 };
2633
2634 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
2635 this);
2636
2637 if (count == null) {
2638 StringBundler query = new StringBundler(2);
2639
2640 query.append(_SQL_COUNT_SOCIALRELATION_WHERE);
2641
2642 query.append(_FINDER_COLUMN_USERID2_USERID2_2);
2643
2644 String sql = query.toString();
2645
2646 Session session = null;
2647
2648 try {
2649 session = openSession();
2650
2651 Query q = session.createQuery(sql);
2652
2653 QueryPos qPos = QueryPos.getInstance(q);
2654
2655 qPos.add(userId2);
2656
2657 count = (Long)q.uniqueResult();
2658
2659 FinderCacheUtil.putResult(finderPath, finderArgs, count);
2660 }
2661 catch (Exception e) {
2662 FinderCacheUtil.removeResult(finderPath, finderArgs);
2663
2664 throw processException(e);
2665 }
2666 finally {
2667 closeSession(session);
2668 }
2669 }
2670
2671 return count.intValue();
2672 }
2673
2674 private static final String _FINDER_COLUMN_USERID2_USERID2_2 = "socialRelation.userId2 = ?";
2675 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_TYPE = new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
2676 SocialRelationModelImpl.FINDER_CACHE_ENABLED,
2677 SocialRelationImpl.class, FINDER_CLASS_NAME_LIST_WITH_PAGINATION,
2678 "findByType",
2679 new String[] {
2680 Integer.class.getName(),
2681
2682 Integer.class.getName(), Integer.class.getName(),
2683 OrderByComparator.class.getName()
2684 });
2685 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_TYPE = new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
2686 SocialRelationModelImpl.FINDER_CACHE_ENABLED,
2687 SocialRelationImpl.class,
2688 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByType",
2689 new String[] { Integer.class.getName() },
2690 SocialRelationModelImpl.TYPE_COLUMN_BITMASK);
2691 public static final FinderPath FINDER_PATH_COUNT_BY_TYPE = new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
2692 SocialRelationModelImpl.FINDER_CACHE_ENABLED, Long.class,
2693 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByType",
2694 new String[] { Integer.class.getName() });
2695
2696
2703 @Override
2704 public List<SocialRelation> findByType(int type) throws SystemException {
2705 return findByType(type, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
2706 }
2707
2708
2721 @Override
2722 public List<SocialRelation> findByType(int type, int start, int end)
2723 throws SystemException {
2724 return findByType(type, start, end, null);
2725 }
2726
2727
2741 @Override
2742 public List<SocialRelation> findByType(int type, int start, int end,
2743 OrderByComparator orderByComparator) throws SystemException {
2744 boolean pagination = true;
2745 FinderPath finderPath = null;
2746 Object[] finderArgs = null;
2747
2748 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
2749 (orderByComparator == null)) {
2750 pagination = false;
2751 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_TYPE;
2752 finderArgs = new Object[] { type };
2753 }
2754 else {
2755 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_TYPE;
2756 finderArgs = new Object[] { type, start, end, orderByComparator };
2757 }
2758
2759 List<SocialRelation> list = (List<SocialRelation>)FinderCacheUtil.getResult(finderPath,
2760 finderArgs, this);
2761
2762 if ((list != null) && !list.isEmpty()) {
2763 for (SocialRelation socialRelation : list) {
2764 if ((type != socialRelation.getType())) {
2765 list = null;
2766
2767 break;
2768 }
2769 }
2770 }
2771
2772 if (list == null) {
2773 StringBundler query = null;
2774
2775 if (orderByComparator != null) {
2776 query = new StringBundler(3 +
2777 (orderByComparator.getOrderByFields().length * 3));
2778 }
2779 else {
2780 query = new StringBundler(3);
2781 }
2782
2783 query.append(_SQL_SELECT_SOCIALRELATION_WHERE);
2784
2785 query.append(_FINDER_COLUMN_TYPE_TYPE_2);
2786
2787 if (orderByComparator != null) {
2788 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2789 orderByComparator);
2790 }
2791 else
2792 if (pagination) {
2793 query.append(SocialRelationModelImpl.ORDER_BY_JPQL);
2794 }
2795
2796 String sql = query.toString();
2797
2798 Session session = null;
2799
2800 try {
2801 session = openSession();
2802
2803 Query q = session.createQuery(sql);
2804
2805 QueryPos qPos = QueryPos.getInstance(q);
2806
2807 qPos.add(type);
2808
2809 if (!pagination) {
2810 list = (List<SocialRelation>)QueryUtil.list(q,
2811 getDialect(), start, end, false);
2812
2813 Collections.sort(list);
2814
2815 list = new UnmodifiableList<SocialRelation>(list);
2816 }
2817 else {
2818 list = (List<SocialRelation>)QueryUtil.list(q,
2819 getDialect(), start, end);
2820 }
2821
2822 cacheResult(list);
2823
2824 FinderCacheUtil.putResult(finderPath, finderArgs, list);
2825 }
2826 catch (Exception e) {
2827 FinderCacheUtil.removeResult(finderPath, finderArgs);
2828
2829 throw processException(e);
2830 }
2831 finally {
2832 closeSession(session);
2833 }
2834 }
2835
2836 return list;
2837 }
2838
2839
2848 @Override
2849 public SocialRelation findByType_First(int type,
2850 OrderByComparator orderByComparator)
2851 throws NoSuchRelationException, SystemException {
2852 SocialRelation socialRelation = fetchByType_First(type,
2853 orderByComparator);
2854
2855 if (socialRelation != null) {
2856 return socialRelation;
2857 }
2858
2859 StringBundler msg = new StringBundler(4);
2860
2861 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2862
2863 msg.append("type=");
2864 msg.append(type);
2865
2866 msg.append(StringPool.CLOSE_CURLY_BRACE);
2867
2868 throw new NoSuchRelationException(msg.toString());
2869 }
2870
2871
2879 @Override
2880 public SocialRelation fetchByType_First(int type,
2881 OrderByComparator orderByComparator) throws SystemException {
2882 List<SocialRelation> list = findByType(type, 0, 1, orderByComparator);
2883
2884 if (!list.isEmpty()) {
2885 return list.get(0);
2886 }
2887
2888 return null;
2889 }
2890
2891
2900 @Override
2901 public SocialRelation findByType_Last(int type,
2902 OrderByComparator orderByComparator)
2903 throws NoSuchRelationException, SystemException {
2904 SocialRelation socialRelation = fetchByType_Last(type, orderByComparator);
2905
2906 if (socialRelation != null) {
2907 return socialRelation;
2908 }
2909
2910 StringBundler msg = new StringBundler(4);
2911
2912 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2913
2914 msg.append("type=");
2915 msg.append(type);
2916
2917 msg.append(StringPool.CLOSE_CURLY_BRACE);
2918
2919 throw new NoSuchRelationException(msg.toString());
2920 }
2921
2922
2930 @Override
2931 public SocialRelation fetchByType_Last(int type,
2932 OrderByComparator orderByComparator) throws SystemException {
2933 int count = countByType(type);
2934
2935 if (count == 0) {
2936 return null;
2937 }
2938
2939 List<SocialRelation> list = findByType(type, count - 1, count,
2940 orderByComparator);
2941
2942 if (!list.isEmpty()) {
2943 return list.get(0);
2944 }
2945
2946 return null;
2947 }
2948
2949
2959 @Override
2960 public SocialRelation[] findByType_PrevAndNext(long relationId, int type,
2961 OrderByComparator orderByComparator)
2962 throws NoSuchRelationException, SystemException {
2963 SocialRelation socialRelation = findByPrimaryKey(relationId);
2964
2965 Session session = null;
2966
2967 try {
2968 session = openSession();
2969
2970 SocialRelation[] array = new SocialRelationImpl[3];
2971
2972 array[0] = getByType_PrevAndNext(session, socialRelation, type,
2973 orderByComparator, true);
2974
2975 array[1] = socialRelation;
2976
2977 array[2] = getByType_PrevAndNext(session, socialRelation, type,
2978 orderByComparator, false);
2979
2980 return array;
2981 }
2982 catch (Exception e) {
2983 throw processException(e);
2984 }
2985 finally {
2986 closeSession(session);
2987 }
2988 }
2989
2990 protected SocialRelation getByType_PrevAndNext(Session session,
2991 SocialRelation socialRelation, int type,
2992 OrderByComparator orderByComparator, boolean previous) {
2993 StringBundler query = null;
2994
2995 if (orderByComparator != null) {
2996 query = new StringBundler(6 +
2997 (orderByComparator.getOrderByFields().length * 6));
2998 }
2999 else {
3000 query = new StringBundler(3);
3001 }
3002
3003 query.append(_SQL_SELECT_SOCIALRELATION_WHERE);
3004
3005 query.append(_FINDER_COLUMN_TYPE_TYPE_2);
3006
3007 if (orderByComparator != null) {
3008 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
3009
3010 if (orderByConditionFields.length > 0) {
3011 query.append(WHERE_AND);
3012 }
3013
3014 for (int i = 0; i < orderByConditionFields.length; i++) {
3015 query.append(_ORDER_BY_ENTITY_ALIAS);
3016 query.append(orderByConditionFields[i]);
3017
3018 if ((i + 1) < orderByConditionFields.length) {
3019 if (orderByComparator.isAscending() ^ previous) {
3020 query.append(WHERE_GREATER_THAN_HAS_NEXT);
3021 }
3022 else {
3023 query.append(WHERE_LESSER_THAN_HAS_NEXT);
3024 }
3025 }
3026 else {
3027 if (orderByComparator.isAscending() ^ previous) {
3028 query.append(WHERE_GREATER_THAN);
3029 }
3030 else {
3031 query.append(WHERE_LESSER_THAN);
3032 }
3033 }
3034 }
3035
3036 query.append(ORDER_BY_CLAUSE);
3037
3038 String[] orderByFields = orderByComparator.getOrderByFields();
3039
3040 for (int i = 0; i < orderByFields.length; i++) {
3041 query.append(_ORDER_BY_ENTITY_ALIAS);
3042 query.append(orderByFields[i]);
3043
3044 if ((i + 1) < orderByFields.length) {
3045 if (orderByComparator.isAscending() ^ previous) {
3046 query.append(ORDER_BY_ASC_HAS_NEXT);
3047 }
3048 else {
3049 query.append(ORDER_BY_DESC_HAS_NEXT);
3050 }
3051 }
3052 else {
3053 if (orderByComparator.isAscending() ^ previous) {
3054 query.append(ORDER_BY_ASC);
3055 }
3056 else {
3057 query.append(ORDER_BY_DESC);
3058 }
3059 }
3060 }
3061 }
3062 else {
3063 query.append(SocialRelationModelImpl.ORDER_BY_JPQL);
3064 }
3065
3066 String sql = query.toString();
3067
3068 Query q = session.createQuery(sql);
3069
3070 q.setFirstResult(0);
3071 q.setMaxResults(2);
3072
3073 QueryPos qPos = QueryPos.getInstance(q);
3074
3075 qPos.add(type);
3076
3077 if (orderByComparator != null) {
3078 Object[] values = orderByComparator.getOrderByConditionValues(socialRelation);
3079
3080 for (Object value : values) {
3081 qPos.add(value);
3082 }
3083 }
3084
3085 List<SocialRelation> list = q.list();
3086
3087 if (list.size() == 2) {
3088 return list.get(1);
3089 }
3090 else {
3091 return null;
3092 }
3093 }
3094
3095
3101 @Override
3102 public void removeByType(int type) throws SystemException {
3103 for (SocialRelation socialRelation : findByType(type,
3104 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
3105 remove(socialRelation);
3106 }
3107 }
3108
3109
3116 @Override
3117 public int countByType(int type) throws SystemException {
3118 FinderPath finderPath = FINDER_PATH_COUNT_BY_TYPE;
3119
3120 Object[] finderArgs = new Object[] { type };
3121
3122 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
3123 this);
3124
3125 if (count == null) {
3126 StringBundler query = new StringBundler(2);
3127
3128 query.append(_SQL_COUNT_SOCIALRELATION_WHERE);
3129
3130 query.append(_FINDER_COLUMN_TYPE_TYPE_2);
3131
3132 String sql = query.toString();
3133
3134 Session session = null;
3135
3136 try {
3137 session = openSession();
3138
3139 Query q = session.createQuery(sql);
3140
3141 QueryPos qPos = QueryPos.getInstance(q);
3142
3143 qPos.add(type);
3144
3145 count = (Long)q.uniqueResult();
3146
3147 FinderCacheUtil.putResult(finderPath, finderArgs, count);
3148 }
3149 catch (Exception e) {
3150 FinderCacheUtil.removeResult(finderPath, finderArgs);
3151
3152 throw processException(e);
3153 }
3154 finally {
3155 closeSession(session);
3156 }
3157 }
3158
3159 return count.intValue();
3160 }
3161
3162 private static final String _FINDER_COLUMN_TYPE_TYPE_2 = "socialRelation.type = ?";
3163 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_C_T = new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
3164 SocialRelationModelImpl.FINDER_CACHE_ENABLED,
3165 SocialRelationImpl.class, FINDER_CLASS_NAME_LIST_WITH_PAGINATION,
3166 "findByC_T",
3167 new String[] {
3168 Long.class.getName(), Integer.class.getName(),
3169
3170 Integer.class.getName(), Integer.class.getName(),
3171 OrderByComparator.class.getName()
3172 });
3173 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_C_T = new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
3174 SocialRelationModelImpl.FINDER_CACHE_ENABLED,
3175 SocialRelationImpl.class,
3176 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByC_T",
3177 new String[] { Long.class.getName(), Integer.class.getName() },
3178 SocialRelationModelImpl.COMPANYID_COLUMN_BITMASK |
3179 SocialRelationModelImpl.TYPE_COLUMN_BITMASK);
3180 public static final FinderPath FINDER_PATH_COUNT_BY_C_T = new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
3181 SocialRelationModelImpl.FINDER_CACHE_ENABLED, Long.class,
3182 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByC_T",
3183 new String[] { Long.class.getName(), Integer.class.getName() });
3184
3185
3193 @Override
3194 public List<SocialRelation> findByC_T(long companyId, int type)
3195 throws SystemException {
3196 return findByC_T(companyId, type, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
3197 null);
3198 }
3199
3200
3214 @Override
3215 public List<SocialRelation> findByC_T(long companyId, int type, int start,
3216 int end) throws SystemException {
3217 return findByC_T(companyId, type, start, end, null);
3218 }
3219
3220
3235 @Override
3236 public List<SocialRelation> findByC_T(long companyId, int type, int start,
3237 int end, OrderByComparator orderByComparator) throws SystemException {
3238 boolean pagination = true;
3239 FinderPath finderPath = null;
3240 Object[] finderArgs = null;
3241
3242 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
3243 (orderByComparator == null)) {
3244 pagination = false;
3245 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_C_T;
3246 finderArgs = new Object[] { companyId, type };
3247 }
3248 else {
3249 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_C_T;
3250 finderArgs = new Object[] {
3251 companyId, type,
3252
3253 start, end, orderByComparator
3254 };
3255 }
3256
3257 List<SocialRelation> list = (List<SocialRelation>)FinderCacheUtil.getResult(finderPath,
3258 finderArgs, this);
3259
3260 if ((list != null) && !list.isEmpty()) {
3261 for (SocialRelation socialRelation : list) {
3262 if ((companyId != socialRelation.getCompanyId()) ||
3263 (type != socialRelation.getType())) {
3264 list = null;
3265
3266 break;
3267 }
3268 }
3269 }
3270
3271 if (list == null) {
3272 StringBundler query = null;
3273
3274 if (orderByComparator != null) {
3275 query = new StringBundler(4 +
3276 (orderByComparator.getOrderByFields().length * 3));
3277 }
3278 else {
3279 query = new StringBundler(4);
3280 }
3281
3282 query.append(_SQL_SELECT_SOCIALRELATION_WHERE);
3283
3284 query.append(_FINDER_COLUMN_C_T_COMPANYID_2);
3285
3286 query.append(_FINDER_COLUMN_C_T_TYPE_2);
3287
3288 if (orderByComparator != null) {
3289 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
3290 orderByComparator);
3291 }
3292 else
3293 if (pagination) {
3294 query.append(SocialRelationModelImpl.ORDER_BY_JPQL);
3295 }
3296
3297 String sql = query.toString();
3298
3299 Session session = null;
3300
3301 try {
3302 session = openSession();
3303
3304 Query q = session.createQuery(sql);
3305
3306 QueryPos qPos = QueryPos.getInstance(q);
3307
3308 qPos.add(companyId);
3309
3310 qPos.add(type);
3311
3312 if (!pagination) {
3313 list = (List<SocialRelation>)QueryUtil.list(q,
3314 getDialect(), start, end, false);
3315
3316 Collections.sort(list);
3317
3318 list = new UnmodifiableList<SocialRelation>(list);
3319 }
3320 else {
3321 list = (List<SocialRelation>)QueryUtil.list(q,
3322 getDialect(), start, end);
3323 }
3324
3325 cacheResult(list);
3326
3327 FinderCacheUtil.putResult(finderPath, finderArgs, list);
3328 }
3329 catch (Exception e) {
3330 FinderCacheUtil.removeResult(finderPath, finderArgs);
3331
3332 throw processException(e);
3333 }
3334 finally {
3335 closeSession(session);
3336 }
3337 }
3338
3339 return list;
3340 }
3341
3342
3352 @Override
3353 public SocialRelation findByC_T_First(long companyId, int type,
3354 OrderByComparator orderByComparator)
3355 throws NoSuchRelationException, SystemException {
3356 SocialRelation socialRelation = fetchByC_T_First(companyId, type,
3357 orderByComparator);
3358
3359 if (socialRelation != null) {
3360 return socialRelation;
3361 }
3362
3363 StringBundler msg = new StringBundler(6);
3364
3365 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3366
3367 msg.append("companyId=");
3368 msg.append(companyId);
3369
3370 msg.append(", type=");
3371 msg.append(type);
3372
3373 msg.append(StringPool.CLOSE_CURLY_BRACE);
3374
3375 throw new NoSuchRelationException(msg.toString());
3376 }
3377
3378
3387 @Override
3388 public SocialRelation fetchByC_T_First(long companyId, int type,
3389 OrderByComparator orderByComparator) throws SystemException {
3390 List<SocialRelation> list = findByC_T(companyId, type, 0, 1,
3391 orderByComparator);
3392
3393 if (!list.isEmpty()) {
3394 return list.get(0);
3395 }
3396
3397 return null;
3398 }
3399
3400
3410 @Override
3411 public SocialRelation findByC_T_Last(long companyId, int type,
3412 OrderByComparator orderByComparator)
3413 throws NoSuchRelationException, SystemException {
3414 SocialRelation socialRelation = fetchByC_T_Last(companyId, type,
3415 orderByComparator);
3416
3417 if (socialRelation != null) {
3418 return socialRelation;
3419 }
3420
3421 StringBundler msg = new StringBundler(6);
3422
3423 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3424
3425 msg.append("companyId=");
3426 msg.append(companyId);
3427
3428 msg.append(", type=");
3429 msg.append(type);
3430
3431 msg.append(StringPool.CLOSE_CURLY_BRACE);
3432
3433 throw new NoSuchRelationException(msg.toString());
3434 }
3435
3436
3445 @Override
3446 public SocialRelation fetchByC_T_Last(long companyId, int type,
3447 OrderByComparator orderByComparator) throws SystemException {
3448 int count = countByC_T(companyId, type);
3449
3450 if (count == 0) {
3451 return null;
3452 }
3453
3454 List<SocialRelation> list = findByC_T(companyId, type, count - 1,
3455 count, orderByComparator);
3456
3457 if (!list.isEmpty()) {
3458 return list.get(0);
3459 }
3460
3461 return null;
3462 }
3463
3464
3475 @Override
3476 public SocialRelation[] findByC_T_PrevAndNext(long relationId,
3477 long companyId, int type, OrderByComparator orderByComparator)
3478 throws NoSuchRelationException, SystemException {
3479 SocialRelation socialRelation = findByPrimaryKey(relationId);
3480
3481 Session session = null;
3482
3483 try {
3484 session = openSession();
3485
3486 SocialRelation[] array = new SocialRelationImpl[3];
3487
3488 array[0] = getByC_T_PrevAndNext(session, socialRelation, companyId,
3489 type, orderByComparator, true);
3490
3491 array[1] = socialRelation;
3492
3493 array[2] = getByC_T_PrevAndNext(session, socialRelation, companyId,
3494 type, orderByComparator, false);
3495
3496 return array;
3497 }
3498 catch (Exception e) {
3499 throw processException(e);
3500 }
3501 finally {
3502 closeSession(session);
3503 }
3504 }
3505
3506 protected SocialRelation getByC_T_PrevAndNext(Session session,
3507 SocialRelation socialRelation, long companyId, int type,
3508 OrderByComparator orderByComparator, boolean previous) {
3509 StringBundler query = null;
3510
3511 if (orderByComparator != null) {
3512 query = new StringBundler(6 +
3513 (orderByComparator.getOrderByFields().length * 6));
3514 }
3515 else {
3516 query = new StringBundler(3);
3517 }
3518
3519 query.append(_SQL_SELECT_SOCIALRELATION_WHERE);
3520
3521 query.append(_FINDER_COLUMN_C_T_COMPANYID_2);
3522
3523 query.append(_FINDER_COLUMN_C_T_TYPE_2);
3524
3525 if (orderByComparator != null) {
3526 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
3527
3528 if (orderByConditionFields.length > 0) {
3529 query.append(WHERE_AND);
3530 }
3531
3532 for (int i = 0; i < orderByConditionFields.length; i++) {
3533 query.append(_ORDER_BY_ENTITY_ALIAS);
3534 query.append(orderByConditionFields[i]);
3535
3536 if ((i + 1) < orderByConditionFields.length) {
3537 if (orderByComparator.isAscending() ^ previous) {
3538 query.append(WHERE_GREATER_THAN_HAS_NEXT);
3539 }
3540 else {
3541 query.append(WHERE_LESSER_THAN_HAS_NEXT);
3542 }
3543 }
3544 else {
3545 if (orderByComparator.isAscending() ^ previous) {
3546 query.append(WHERE_GREATER_THAN);
3547 }
3548 else {
3549 query.append(WHERE_LESSER_THAN);
3550 }
3551 }
3552 }
3553
3554 query.append(ORDER_BY_CLAUSE);
3555
3556 String[] orderByFields = orderByComparator.getOrderByFields();
3557
3558 for (int i = 0; i < orderByFields.length; i++) {
3559 query.append(_ORDER_BY_ENTITY_ALIAS);
3560 query.append(orderByFields[i]);
3561
3562 if ((i + 1) < orderByFields.length) {
3563 if (orderByComparator.isAscending() ^ previous) {
3564 query.append(ORDER_BY_ASC_HAS_NEXT);
3565 }
3566 else {
3567 query.append(ORDER_BY_DESC_HAS_NEXT);
3568 }
3569 }
3570 else {
3571 if (orderByComparator.isAscending() ^ previous) {
3572 query.append(ORDER_BY_ASC);
3573 }
3574 else {
3575 query.append(ORDER_BY_DESC);
3576 }
3577 }
3578 }
3579 }
3580 else {
3581 query.append(SocialRelationModelImpl.ORDER_BY_JPQL);
3582 }
3583
3584 String sql = query.toString();
3585
3586 Query q = session.createQuery(sql);
3587
3588 q.setFirstResult(0);
3589 q.setMaxResults(2);
3590
3591 QueryPos qPos = QueryPos.getInstance(q);
3592
3593 qPos.add(companyId);
3594
3595 qPos.add(type);
3596
3597 if (orderByComparator != null) {
3598 Object[] values = orderByComparator.getOrderByConditionValues(socialRelation);
3599
3600 for (Object value : values) {
3601 qPos.add(value);
3602 }
3603 }
3604
3605 List<SocialRelation> list = q.list();
3606
3607 if (list.size() == 2) {
3608 return list.get(1);
3609 }
3610 else {
3611 return null;
3612 }
3613 }
3614
3615
3622 @Override
3623 public void removeByC_T(long companyId, int type) throws SystemException {
3624 for (SocialRelation socialRelation : findByC_T(companyId, type,
3625 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
3626 remove(socialRelation);
3627 }
3628 }
3629
3630
3638 @Override
3639 public int countByC_T(long companyId, int type) throws SystemException {
3640 FinderPath finderPath = FINDER_PATH_COUNT_BY_C_T;
3641
3642 Object[] finderArgs = new Object[] { companyId, type };
3643
3644 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
3645 this);
3646
3647 if (count == null) {
3648 StringBundler query = new StringBundler(3);
3649
3650 query.append(_SQL_COUNT_SOCIALRELATION_WHERE);
3651
3652 query.append(_FINDER_COLUMN_C_T_COMPANYID_2);
3653
3654 query.append(_FINDER_COLUMN_C_T_TYPE_2);
3655
3656 String sql = query.toString();
3657
3658 Session session = null;
3659
3660 try {
3661 session = openSession();
3662
3663 Query q = session.createQuery(sql);
3664
3665 QueryPos qPos = QueryPos.getInstance(q);
3666
3667 qPos.add(companyId);
3668
3669 qPos.add(type);
3670
3671 count = (Long)q.uniqueResult();
3672
3673 FinderCacheUtil.putResult(finderPath, finderArgs, count);
3674 }
3675 catch (Exception e) {
3676 FinderCacheUtil.removeResult(finderPath, finderArgs);
3677
3678 throw processException(e);
3679 }
3680 finally {
3681 closeSession(session);
3682 }
3683 }
3684
3685 return count.intValue();
3686 }
3687
3688 private static final String _FINDER_COLUMN_C_T_COMPANYID_2 = "socialRelation.companyId = ? AND ";
3689 private static final String _FINDER_COLUMN_C_T_TYPE_2 = "socialRelation.type = ?";
3690 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_U1_U2 = new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
3691 SocialRelationModelImpl.FINDER_CACHE_ENABLED,
3692 SocialRelationImpl.class, FINDER_CLASS_NAME_LIST_WITH_PAGINATION,
3693 "findByU1_U2",
3694 new String[] {
3695 Long.class.getName(), Long.class.getName(),
3696
3697 Integer.class.getName(), Integer.class.getName(),
3698 OrderByComparator.class.getName()
3699 });
3700 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_U1_U2 = new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
3701 SocialRelationModelImpl.FINDER_CACHE_ENABLED,
3702 SocialRelationImpl.class,
3703 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByU1_U2",
3704 new String[] { Long.class.getName(), Long.class.getName() },
3705 SocialRelationModelImpl.USERID1_COLUMN_BITMASK |
3706 SocialRelationModelImpl.USERID2_COLUMN_BITMASK);
3707 public static final FinderPath FINDER_PATH_COUNT_BY_U1_U2 = new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
3708 SocialRelationModelImpl.FINDER_CACHE_ENABLED, Long.class,
3709 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByU1_U2",
3710 new String[] { Long.class.getName(), Long.class.getName() });
3711
3712
3720 @Override
3721 public List<SocialRelation> findByU1_U2(long userId1, long userId2)
3722 throws SystemException {
3723 return findByU1_U2(userId1, userId2, QueryUtil.ALL_POS,
3724 QueryUtil.ALL_POS, null);
3725 }
3726
3727
3741 @Override
3742 public List<SocialRelation> findByU1_U2(long userId1, long userId2,
3743 int start, int end) throws SystemException {
3744 return findByU1_U2(userId1, userId2, start, end, null);
3745 }
3746
3747
3762 @Override
3763 public List<SocialRelation> findByU1_U2(long userId1, long userId2,
3764 int start, int end, OrderByComparator orderByComparator)
3765 throws SystemException {
3766 boolean pagination = true;
3767 FinderPath finderPath = null;
3768 Object[] finderArgs = null;
3769
3770 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
3771 (orderByComparator == null)) {
3772 pagination = false;
3773 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_U1_U2;
3774 finderArgs = new Object[] { userId1, userId2 };
3775 }
3776 else {
3777 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_U1_U2;
3778 finderArgs = new Object[] {
3779 userId1, userId2,
3780
3781 start, end, orderByComparator
3782 };
3783 }
3784
3785 List<SocialRelation> list = (List<SocialRelation>)FinderCacheUtil.getResult(finderPath,
3786 finderArgs, this);
3787
3788 if ((list != null) && !list.isEmpty()) {
3789 for (SocialRelation socialRelation : list) {
3790 if ((userId1 != socialRelation.getUserId1()) ||
3791 (userId2 != socialRelation.getUserId2())) {
3792 list = null;
3793
3794 break;
3795 }
3796 }
3797 }
3798
3799 if (list == null) {
3800 StringBundler query = null;
3801
3802 if (orderByComparator != null) {
3803 query = new StringBundler(4 +
3804 (orderByComparator.getOrderByFields().length * 3));
3805 }
3806 else {
3807 query = new StringBundler(4);
3808 }
3809
3810 query.append(_SQL_SELECT_SOCIALRELATION_WHERE);
3811
3812 query.append(_FINDER_COLUMN_U1_U2_USERID1_2);
3813
3814 query.append(_FINDER_COLUMN_U1_U2_USERID2_2);
3815
3816 if (orderByComparator != null) {
3817 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
3818 orderByComparator);
3819 }
3820 else
3821 if (pagination) {
3822 query.append(SocialRelationModelImpl.ORDER_BY_JPQL);
3823 }
3824
3825 String sql = query.toString();
3826
3827 Session session = null;
3828
3829 try {
3830 session = openSession();
3831
3832 Query q = session.createQuery(sql);
3833
3834 QueryPos qPos = QueryPos.getInstance(q);
3835
3836 qPos.add(userId1);
3837
3838 qPos.add(userId2);
3839
3840 if (!pagination) {
3841 list = (List<SocialRelation>)QueryUtil.list(q,
3842 getDialect(), start, end, false);
3843
3844 Collections.sort(list);
3845
3846 list = new UnmodifiableList<SocialRelation>(list);
3847 }
3848 else {
3849 list = (List<SocialRelation>)QueryUtil.list(q,
3850 getDialect(), start, end);
3851 }
3852
3853 cacheResult(list);
3854
3855 FinderCacheUtil.putResult(finderPath, finderArgs, list);
3856 }
3857 catch (Exception e) {
3858 FinderCacheUtil.removeResult(finderPath, finderArgs);
3859
3860 throw processException(e);
3861 }
3862 finally {
3863 closeSession(session);
3864 }
3865 }
3866
3867 return list;
3868 }
3869
3870
3880 @Override
3881 public SocialRelation findByU1_U2_First(long userId1, long userId2,
3882 OrderByComparator orderByComparator)
3883 throws NoSuchRelationException, SystemException {
3884 SocialRelation socialRelation = fetchByU1_U2_First(userId1, userId2,
3885 orderByComparator);
3886
3887 if (socialRelation != null) {
3888 return socialRelation;
3889 }
3890
3891 StringBundler msg = new StringBundler(6);
3892
3893 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3894
3895 msg.append("userId1=");
3896 msg.append(userId1);
3897
3898 msg.append(", userId2=");
3899 msg.append(userId2);
3900
3901 msg.append(StringPool.CLOSE_CURLY_BRACE);
3902
3903 throw new NoSuchRelationException(msg.toString());
3904 }
3905
3906
3915 @Override
3916 public SocialRelation fetchByU1_U2_First(long userId1, long userId2,
3917 OrderByComparator orderByComparator) throws SystemException {
3918 List<SocialRelation> list = findByU1_U2(userId1, userId2, 0, 1,
3919 orderByComparator);
3920
3921 if (!list.isEmpty()) {
3922 return list.get(0);
3923 }
3924
3925 return null;
3926 }
3927
3928
3938 @Override
3939 public SocialRelation findByU1_U2_Last(long userId1, long userId2,
3940 OrderByComparator orderByComparator)
3941 throws NoSuchRelationException, SystemException {
3942 SocialRelation socialRelation = fetchByU1_U2_Last(userId1, userId2,
3943 orderByComparator);
3944
3945 if (socialRelation != null) {
3946 return socialRelation;
3947 }
3948
3949 StringBundler msg = new StringBundler(6);
3950
3951 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3952
3953 msg.append("userId1=");
3954 msg.append(userId1);
3955
3956 msg.append(", userId2=");
3957 msg.append(userId2);
3958
3959 msg.append(StringPool.CLOSE_CURLY_BRACE);
3960
3961 throw new NoSuchRelationException(msg.toString());
3962 }
3963
3964
3973 @Override
3974 public SocialRelation fetchByU1_U2_Last(long userId1, long userId2,
3975 OrderByComparator orderByComparator) throws SystemException {
3976 int count = countByU1_U2(userId1, userId2);
3977
3978 if (count == 0) {
3979 return null;
3980 }
3981
3982 List<SocialRelation> list = findByU1_U2(userId1, userId2, count - 1,
3983 count, orderByComparator);
3984
3985 if (!list.isEmpty()) {
3986 return list.get(0);
3987 }
3988
3989 return null;
3990 }
3991
3992
4003 @Override
4004 public SocialRelation[] findByU1_U2_PrevAndNext(long relationId,
4005 long userId1, long userId2, OrderByComparator orderByComparator)
4006 throws NoSuchRelationException, SystemException {
4007 SocialRelation socialRelation = findByPrimaryKey(relationId);
4008
4009 Session session = null;
4010
4011 try {
4012 session = openSession();
4013
4014 SocialRelation[] array = new SocialRelationImpl[3];
4015
4016 array[0] = getByU1_U2_PrevAndNext(session, socialRelation, userId1,
4017 userId2, orderByComparator, true);
4018
4019 array[1] = socialRelation;
4020
4021 array[2] = getByU1_U2_PrevAndNext(session, socialRelation, userId1,
4022 userId2, orderByComparator, false);
4023
4024 return array;
4025 }
4026 catch (Exception e) {
4027 throw processException(e);
4028 }
4029 finally {
4030 closeSession(session);
4031 }
4032 }
4033
4034 protected SocialRelation getByU1_U2_PrevAndNext(Session session,
4035 SocialRelation socialRelation, long userId1, long userId2,
4036 OrderByComparator orderByComparator, boolean previous) {
4037 StringBundler query = null;
4038
4039 if (orderByComparator != null) {
4040 query = new StringBundler(6 +
4041 (orderByComparator.getOrderByFields().length * 6));
4042 }
4043 else {
4044 query = new StringBundler(3);
4045 }
4046
4047 query.append(_SQL_SELECT_SOCIALRELATION_WHERE);
4048
4049 query.append(_FINDER_COLUMN_U1_U2_USERID1_2);
4050
4051 query.append(_FINDER_COLUMN_U1_U2_USERID2_2);
4052
4053 if (orderByComparator != null) {
4054 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
4055
4056 if (orderByConditionFields.length > 0) {
4057 query.append(WHERE_AND);
4058 }
4059
4060 for (int i = 0; i < orderByConditionFields.length; i++) {
4061 query.append(_ORDER_BY_ENTITY_ALIAS);
4062 query.append(orderByConditionFields[i]);
4063
4064 if ((i + 1) < orderByConditionFields.length) {
4065 if (orderByComparator.isAscending() ^ previous) {
4066 query.append(WHERE_GREATER_THAN_HAS_NEXT);
4067 }
4068 else {
4069 query.append(WHERE_LESSER_THAN_HAS_NEXT);
4070 }
4071 }
4072 else {
4073 if (orderByComparator.isAscending() ^ previous) {
4074 query.append(WHERE_GREATER_THAN);
4075 }
4076 else {
4077 query.append(WHERE_LESSER_THAN);
4078 }
4079 }
4080 }
4081
4082 query.append(ORDER_BY_CLAUSE);
4083
4084 String[] orderByFields = orderByComparator.getOrderByFields();
4085
4086 for (int i = 0; i < orderByFields.length; i++) {
4087 query.append(_ORDER_BY_ENTITY_ALIAS);
4088 query.append(orderByFields[i]);
4089
4090 if ((i + 1) < orderByFields.length) {
4091 if (orderByComparator.isAscending() ^ previous) {
4092 query.append(ORDER_BY_ASC_HAS_NEXT);
4093 }
4094 else {
4095 query.append(ORDER_BY_DESC_HAS_NEXT);
4096 }
4097 }
4098 else {
4099 if (orderByComparator.isAscending() ^ previous) {
4100 query.append(ORDER_BY_ASC);
4101 }
4102 else {
4103 query.append(ORDER_BY_DESC);
4104 }
4105 }
4106 }
4107 }
4108 else {
4109 query.append(SocialRelationModelImpl.ORDER_BY_JPQL);
4110 }
4111
4112 String sql = query.toString();
4113
4114 Query q = session.createQuery(sql);
4115
4116 q.setFirstResult(0);
4117 q.setMaxResults(2);
4118
4119 QueryPos qPos = QueryPos.getInstance(q);
4120
4121 qPos.add(userId1);
4122
4123 qPos.add(userId2);
4124
4125 if (orderByComparator != null) {
4126 Object[] values = orderByComparator.getOrderByConditionValues(socialRelation);
4127
4128 for (Object value : values) {
4129 qPos.add(value);
4130 }
4131 }
4132
4133 List<SocialRelation> list = q.list();
4134
4135 if (list.size() == 2) {
4136 return list.get(1);
4137 }
4138 else {
4139 return null;
4140 }
4141 }
4142
4143
4150 @Override
4151 public void removeByU1_U2(long userId1, long userId2)
4152 throws SystemException {
4153 for (SocialRelation socialRelation : findByU1_U2(userId1, userId2,
4154 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
4155 remove(socialRelation);
4156 }
4157 }
4158
4159
4167 @Override
4168 public int countByU1_U2(long userId1, long userId2)
4169 throws SystemException {
4170 FinderPath finderPath = FINDER_PATH_COUNT_BY_U1_U2;
4171
4172 Object[] finderArgs = new Object[] { userId1, userId2 };
4173
4174 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
4175 this);
4176
4177 if (count == null) {
4178 StringBundler query = new StringBundler(3);
4179
4180 query.append(_SQL_COUNT_SOCIALRELATION_WHERE);
4181
4182 query.append(_FINDER_COLUMN_U1_U2_USERID1_2);
4183
4184 query.append(_FINDER_COLUMN_U1_U2_USERID2_2);
4185
4186 String sql = query.toString();
4187
4188 Session session = null;
4189
4190 try {
4191 session = openSession();
4192
4193 Query q = session.createQuery(sql);
4194
4195 QueryPos qPos = QueryPos.getInstance(q);
4196
4197 qPos.add(userId1);
4198
4199 qPos.add(userId2);
4200
4201 count = (Long)q.uniqueResult();
4202
4203 FinderCacheUtil.putResult(finderPath, finderArgs, count);
4204 }
4205 catch (Exception e) {
4206 FinderCacheUtil.removeResult(finderPath, finderArgs);
4207
4208 throw processException(e);
4209 }
4210 finally {
4211 closeSession(session);
4212 }
4213 }
4214
4215 return count.intValue();
4216 }
4217
4218 private static final String _FINDER_COLUMN_U1_U2_USERID1_2 = "socialRelation.userId1 = ? AND ";
4219 private static final String _FINDER_COLUMN_U1_U2_USERID2_2 = "socialRelation.userId2 = ?";
4220 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_U1_T = new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
4221 SocialRelationModelImpl.FINDER_CACHE_ENABLED,
4222 SocialRelationImpl.class, FINDER_CLASS_NAME_LIST_WITH_PAGINATION,
4223 "findByU1_T",
4224 new String[] {
4225 Long.class.getName(), Integer.class.getName(),
4226
4227 Integer.class.getName(), Integer.class.getName(),
4228 OrderByComparator.class.getName()
4229 });
4230 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_U1_T = new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
4231 SocialRelationModelImpl.FINDER_CACHE_ENABLED,
4232 SocialRelationImpl.class,
4233 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByU1_T",
4234 new String[] { Long.class.getName(), Integer.class.getName() },
4235 SocialRelationModelImpl.USERID1_COLUMN_BITMASK |
4236 SocialRelationModelImpl.TYPE_COLUMN_BITMASK);
4237 public static final FinderPath FINDER_PATH_COUNT_BY_U1_T = new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
4238 SocialRelationModelImpl.FINDER_CACHE_ENABLED, Long.class,
4239 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByU1_T",
4240 new String[] { Long.class.getName(), Integer.class.getName() });
4241
4242
4250 @Override
4251 public List<SocialRelation> findByU1_T(long userId1, int type)
4252 throws SystemException {
4253 return findByU1_T(userId1, type, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
4254 null);
4255 }
4256
4257
4271 @Override
4272 public List<SocialRelation> findByU1_T(long userId1, int type, int start,
4273 int end) throws SystemException {
4274 return findByU1_T(userId1, type, start, end, null);
4275 }
4276
4277
4292 @Override
4293 public List<SocialRelation> findByU1_T(long userId1, int type, int start,
4294 int end, OrderByComparator orderByComparator) throws SystemException {
4295 boolean pagination = true;
4296 FinderPath finderPath = null;
4297 Object[] finderArgs = null;
4298
4299 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
4300 (orderByComparator == null)) {
4301 pagination = false;
4302 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_U1_T;
4303 finderArgs = new Object[] { userId1, type };
4304 }
4305 else {
4306 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_U1_T;
4307 finderArgs = new Object[] {
4308 userId1, type,
4309
4310 start, end, orderByComparator
4311 };
4312 }
4313
4314 List<SocialRelation> list = (List<SocialRelation>)FinderCacheUtil.getResult(finderPath,
4315 finderArgs, this);
4316
4317 if ((list != null) && !list.isEmpty()) {
4318 for (SocialRelation socialRelation : list) {
4319 if ((userId1 != socialRelation.getUserId1()) ||
4320 (type != socialRelation.getType())) {
4321 list = null;
4322
4323 break;
4324 }
4325 }
4326 }
4327
4328 if (list == null) {
4329 StringBundler query = null;
4330
4331 if (orderByComparator != null) {
4332 query = new StringBundler(4 +
4333 (orderByComparator.getOrderByFields().length * 3));
4334 }
4335 else {
4336 query = new StringBundler(4);
4337 }
4338
4339 query.append(_SQL_SELECT_SOCIALRELATION_WHERE);
4340
4341 query.append(_FINDER_COLUMN_U1_T_USERID1_2);
4342
4343 query.append(_FINDER_COLUMN_U1_T_TYPE_2);
4344
4345 if (orderByComparator != null) {
4346 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
4347 orderByComparator);
4348 }
4349 else
4350 if (pagination) {
4351 query.append(SocialRelationModelImpl.ORDER_BY_JPQL);
4352 }
4353
4354 String sql = query.toString();
4355
4356 Session session = null;
4357
4358 try {
4359 session = openSession();
4360
4361 Query q = session.createQuery(sql);
4362
4363 QueryPos qPos = QueryPos.getInstance(q);
4364
4365 qPos.add(userId1);
4366
4367 qPos.add(type);
4368
4369 if (!pagination) {
4370 list = (List<SocialRelation>)QueryUtil.list(q,
4371 getDialect(), start, end, false);
4372
4373 Collections.sort(list);
4374
4375 list = new UnmodifiableList<SocialRelation>(list);
4376 }
4377 else {
4378 list = (List<SocialRelation>)QueryUtil.list(q,
4379 getDialect(), start, end);
4380 }
4381
4382 cacheResult(list);
4383
4384 FinderCacheUtil.putResult(finderPath, finderArgs, list);
4385 }
4386 catch (Exception e) {
4387 FinderCacheUtil.removeResult(finderPath, finderArgs);
4388
4389 throw processException(e);
4390 }
4391 finally {
4392 closeSession(session);
4393 }
4394 }
4395
4396 return list;
4397 }
4398
4399
4409 @Override
4410 public SocialRelation findByU1_T_First(long userId1, int type,
4411 OrderByComparator orderByComparator)
4412 throws NoSuchRelationException, SystemException {
4413 SocialRelation socialRelation = fetchByU1_T_First(userId1, type,
4414 orderByComparator);
4415
4416 if (socialRelation != null) {
4417 return socialRelation;
4418 }
4419
4420 StringBundler msg = new StringBundler(6);
4421
4422 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
4423
4424 msg.append("userId1=");
4425 msg.append(userId1);
4426
4427 msg.append(", type=");
4428 msg.append(type);
4429
4430 msg.append(StringPool.CLOSE_CURLY_BRACE);
4431
4432 throw new NoSuchRelationException(msg.toString());
4433 }
4434
4435
4444 @Override
4445 public SocialRelation fetchByU1_T_First(long userId1, int type,
4446 OrderByComparator orderByComparator) throws SystemException {
4447 List<SocialRelation> list = findByU1_T(userId1, type, 0, 1,
4448 orderByComparator);
4449
4450 if (!list.isEmpty()) {
4451 return list.get(0);
4452 }
4453
4454 return null;
4455 }
4456
4457
4467 @Override
4468 public SocialRelation findByU1_T_Last(long userId1, int type,
4469 OrderByComparator orderByComparator)
4470 throws NoSuchRelationException, SystemException {
4471 SocialRelation socialRelation = fetchByU1_T_Last(userId1, type,
4472 orderByComparator);
4473
4474 if (socialRelation != null) {
4475 return socialRelation;
4476 }
4477
4478 StringBundler msg = new StringBundler(6);
4479
4480 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
4481
4482 msg.append("userId1=");
4483 msg.append(userId1);
4484
4485 msg.append(", type=");
4486 msg.append(type);
4487
4488 msg.append(StringPool.CLOSE_CURLY_BRACE);
4489
4490 throw new NoSuchRelationException(msg.toString());
4491 }
4492
4493
4502 @Override
4503 public SocialRelation fetchByU1_T_Last(long userId1, int type,
4504 OrderByComparator orderByComparator) throws SystemException {
4505 int count = countByU1_T(userId1, type);
4506
4507 if (count == 0) {
4508 return null;
4509 }
4510
4511 List<SocialRelation> list = findByU1_T(userId1, type, count - 1, count,
4512 orderByComparator);
4513
4514 if (!list.isEmpty()) {
4515 return list.get(0);
4516 }
4517
4518 return null;
4519 }
4520
4521
4532 @Override
4533 public SocialRelation[] findByU1_T_PrevAndNext(long relationId,
4534 long userId1, int type, OrderByComparator orderByComparator)
4535 throws NoSuchRelationException, SystemException {
4536 SocialRelation socialRelation = findByPrimaryKey(relationId);
4537
4538 Session session = null;
4539
4540 try {
4541 session = openSession();
4542
4543 SocialRelation[] array = new SocialRelationImpl[3];
4544
4545 array[0] = getByU1_T_PrevAndNext(session, socialRelation, userId1,
4546 type, orderByComparator, true);
4547
4548 array[1] = socialRelation;
4549
4550 array[2] = getByU1_T_PrevAndNext(session, socialRelation, userId1,
4551 type, orderByComparator, false);
4552
4553 return array;
4554 }
4555 catch (Exception e) {
4556 throw processException(e);
4557 }
4558 finally {
4559 closeSession(session);
4560 }
4561 }
4562
4563 protected SocialRelation getByU1_T_PrevAndNext(Session session,
4564 SocialRelation socialRelation, long userId1, int type,
4565 OrderByComparator orderByComparator, boolean previous) {
4566 StringBundler query = null;
4567
4568 if (orderByComparator != null) {
4569 query = new StringBundler(6 +
4570 (orderByComparator.getOrderByFields().length * 6));
4571 }
4572 else {
4573 query = new StringBundler(3);
4574 }
4575
4576 query.append(_SQL_SELECT_SOCIALRELATION_WHERE);
4577
4578 query.append(_FINDER_COLUMN_U1_T_USERID1_2);
4579
4580 query.append(_FINDER_COLUMN_U1_T_TYPE_2);
4581
4582 if (orderByComparator != null) {
4583 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
4584
4585 if (orderByConditionFields.length > 0) {
4586 query.append(WHERE_AND);
4587 }
4588
4589 for (int i = 0; i < orderByConditionFields.length; i++) {
4590 query.append(_ORDER_BY_ENTITY_ALIAS);
4591 query.append(orderByConditionFields[i]);
4592
4593 if ((i + 1) < orderByConditionFields.length) {
4594 if (orderByComparator.isAscending() ^ previous) {
4595 query.append(WHERE_GREATER_THAN_HAS_NEXT);
4596 }
4597 else {
4598 query.append(WHERE_LESSER_THAN_HAS_NEXT);
4599 }
4600 }
4601 else {
4602 if (orderByComparator.isAscending() ^ previous) {
4603 query.append(WHERE_GREATER_THAN);
4604 }
4605 else {
4606 query.append(WHERE_LESSER_THAN);
4607 }
4608 }
4609 }
4610
4611 query.append(ORDER_BY_CLAUSE);
4612
4613 String[] orderByFields = orderByComparator.getOrderByFields();
4614
4615 for (int i = 0; i < orderByFields.length; i++) {
4616 query.append(_ORDER_BY_ENTITY_ALIAS);
4617 query.append(orderByFields[i]);
4618
4619 if ((i + 1) < orderByFields.length) {
4620 if (orderByComparator.isAscending() ^ previous) {
4621 query.append(ORDER_BY_ASC_HAS_NEXT);
4622 }
4623 else {
4624 query.append(ORDER_BY_DESC_HAS_NEXT);
4625 }
4626 }
4627 else {
4628 if (orderByComparator.isAscending() ^ previous) {
4629 query.append(ORDER_BY_ASC);
4630 }
4631 else {
4632 query.append(ORDER_BY_DESC);
4633 }
4634 }
4635 }
4636 }
4637 else {
4638 query.append(SocialRelationModelImpl.ORDER_BY_JPQL);
4639 }
4640
4641 String sql = query.toString();
4642
4643 Query q = session.createQuery(sql);
4644
4645 q.setFirstResult(0);
4646 q.setMaxResults(2);
4647
4648 QueryPos qPos = QueryPos.getInstance(q);
4649
4650 qPos.add(userId1);
4651
4652 qPos.add(type);
4653
4654 if (orderByComparator != null) {
4655 Object[] values = orderByComparator.getOrderByConditionValues(socialRelation);
4656
4657 for (Object value : values) {
4658 qPos.add(value);
4659 }
4660 }
4661
4662 List<SocialRelation> list = q.list();
4663
4664 if (list.size() == 2) {
4665 return list.get(1);
4666 }
4667 else {
4668 return null;
4669 }
4670 }
4671
4672
4679 @Override
4680 public void removeByU1_T(long userId1, int type) throws SystemException {
4681 for (SocialRelation socialRelation : findByU1_T(userId1, type,
4682 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
4683 remove(socialRelation);
4684 }
4685 }
4686
4687
4695 @Override
4696 public int countByU1_T(long userId1, int type) throws SystemException {
4697 FinderPath finderPath = FINDER_PATH_COUNT_BY_U1_T;
4698
4699 Object[] finderArgs = new Object[] { userId1, type };
4700
4701 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
4702 this);
4703
4704 if (count == null) {
4705 StringBundler query = new StringBundler(3);
4706
4707 query.append(_SQL_COUNT_SOCIALRELATION_WHERE);
4708
4709 query.append(_FINDER_COLUMN_U1_T_USERID1_2);
4710
4711 query.append(_FINDER_COLUMN_U1_T_TYPE_2);
4712
4713 String sql = query.toString();
4714
4715 Session session = null;
4716
4717 try {
4718 session = openSession();
4719
4720 Query q = session.createQuery(sql);
4721
4722 QueryPos qPos = QueryPos.getInstance(q);
4723
4724 qPos.add(userId1);
4725
4726 qPos.add(type);
4727
4728 count = (Long)q.uniqueResult();
4729
4730 FinderCacheUtil.putResult(finderPath, finderArgs, count);
4731 }
4732 catch (Exception e) {
4733 FinderCacheUtil.removeResult(finderPath, finderArgs);
4734
4735 throw processException(e);
4736 }
4737 finally {
4738 closeSession(session);
4739 }
4740 }
4741
4742 return count.intValue();
4743 }
4744
4745 private static final String _FINDER_COLUMN_U1_T_USERID1_2 = "socialRelation.userId1 = ? AND ";
4746 private static final String _FINDER_COLUMN_U1_T_TYPE_2 = "socialRelation.type = ?";
4747 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_U2_T = new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
4748 SocialRelationModelImpl.FINDER_CACHE_ENABLED,
4749 SocialRelationImpl.class, FINDER_CLASS_NAME_LIST_WITH_PAGINATION,
4750 "findByU2_T",
4751 new String[] {
4752 Long.class.getName(), Integer.class.getName(),
4753
4754 Integer.class.getName(), Integer.class.getName(),
4755 OrderByComparator.class.getName()
4756 });
4757 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_U2_T = new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
4758 SocialRelationModelImpl.FINDER_CACHE_ENABLED,
4759 SocialRelationImpl.class,
4760 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByU2_T",
4761 new String[] { Long.class.getName(), Integer.class.getName() },
4762 SocialRelationModelImpl.USERID2_COLUMN_BITMASK |
4763 SocialRelationModelImpl.TYPE_COLUMN_BITMASK);
4764 public static final FinderPath FINDER_PATH_COUNT_BY_U2_T = new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
4765 SocialRelationModelImpl.FINDER_CACHE_ENABLED, Long.class,
4766 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByU2_T",
4767 new String[] { Long.class.getName(), Integer.class.getName() });
4768
4769
4777 @Override
4778 public List<SocialRelation> findByU2_T(long userId2, int type)
4779 throws SystemException {
4780 return findByU2_T(userId2, type, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
4781 null);
4782 }
4783
4784
4798 @Override
4799 public List<SocialRelation> findByU2_T(long userId2, int type, int start,
4800 int end) throws SystemException {
4801 return findByU2_T(userId2, type, start, end, null);
4802 }
4803
4804
4819 @Override
4820 public List<SocialRelation> findByU2_T(long userId2, int type, int start,
4821 int end, OrderByComparator orderByComparator) throws SystemException {
4822 boolean pagination = true;
4823 FinderPath finderPath = null;
4824 Object[] finderArgs = null;
4825
4826 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
4827 (orderByComparator == null)) {
4828 pagination = false;
4829 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_U2_T;
4830 finderArgs = new Object[] { userId2, type };
4831 }
4832 else {
4833 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_U2_T;
4834 finderArgs = new Object[] {
4835 userId2, type,
4836
4837 start, end, orderByComparator
4838 };
4839 }
4840
4841 List<SocialRelation> list = (List<SocialRelation>)FinderCacheUtil.getResult(finderPath,
4842 finderArgs, this);
4843
4844 if ((list != null) && !list.isEmpty()) {
4845 for (SocialRelation socialRelation : list) {
4846 if ((userId2 != socialRelation.getUserId2()) ||
4847 (type != socialRelation.getType())) {
4848 list = null;
4849
4850 break;
4851 }
4852 }
4853 }
4854
4855 if (list == null) {
4856 StringBundler query = null;
4857
4858 if (orderByComparator != null) {
4859 query = new StringBundler(4 +
4860 (orderByComparator.getOrderByFields().length * 3));
4861 }
4862 else {
4863 query = new StringBundler(4);
4864 }
4865
4866 query.append(_SQL_SELECT_SOCIALRELATION_WHERE);
4867
4868 query.append(_FINDER_COLUMN_U2_T_USERID2_2);
4869
4870 query.append(_FINDER_COLUMN_U2_T_TYPE_2);
4871
4872 if (orderByComparator != null) {
4873 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
4874 orderByComparator);
4875 }
4876 else
4877 if (pagination) {
4878 query.append(SocialRelationModelImpl.ORDER_BY_JPQL);
4879 }
4880
4881 String sql = query.toString();
4882
4883 Session session = null;
4884
4885 try {
4886 session = openSession();
4887
4888 Query q = session.createQuery(sql);
4889
4890 QueryPos qPos = QueryPos.getInstance(q);
4891
4892 qPos.add(userId2);
4893
4894 qPos.add(type);
4895
4896 if (!pagination) {
4897 list = (List<SocialRelation>)QueryUtil.list(q,
4898 getDialect(), start, end, false);
4899
4900 Collections.sort(list);
4901
4902 list = new UnmodifiableList<SocialRelation>(list);
4903 }
4904 else {
4905 list = (List<SocialRelation>)QueryUtil.list(q,
4906 getDialect(), start, end);
4907 }
4908
4909 cacheResult(list);
4910
4911 FinderCacheUtil.putResult(finderPath, finderArgs, list);
4912 }
4913 catch (Exception e) {
4914 FinderCacheUtil.removeResult(finderPath, finderArgs);
4915
4916 throw processException(e);
4917 }
4918 finally {
4919 closeSession(session);
4920 }
4921 }
4922
4923 return list;
4924 }
4925
4926
4936 @Override
4937 public SocialRelation findByU2_T_First(long userId2, int type,
4938 OrderByComparator orderByComparator)
4939 throws NoSuchRelationException, SystemException {
4940 SocialRelation socialRelation = fetchByU2_T_First(userId2, type,
4941 orderByComparator);
4942
4943 if (socialRelation != null) {
4944 return socialRelation;
4945 }
4946
4947 StringBundler msg = new StringBundler(6);
4948
4949 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
4950
4951 msg.append("userId2=");
4952 msg.append(userId2);
4953
4954 msg.append(", type=");
4955 msg.append(type);
4956
4957 msg.append(StringPool.CLOSE_CURLY_BRACE);
4958
4959 throw new NoSuchRelationException(msg.toString());
4960 }
4961
4962
4971 @Override
4972 public SocialRelation fetchByU2_T_First(long userId2, int type,
4973 OrderByComparator orderByComparator) throws SystemException {
4974 List<SocialRelation> list = findByU2_T(userId2, type, 0, 1,
4975 orderByComparator);
4976
4977 if (!list.isEmpty()) {
4978 return list.get(0);
4979 }
4980
4981 return null;
4982 }
4983
4984
4994 @Override
4995 public SocialRelation findByU2_T_Last(long userId2, int type,
4996 OrderByComparator orderByComparator)
4997 throws NoSuchRelationException, SystemException {
4998 SocialRelation socialRelation = fetchByU2_T_Last(userId2, type,
4999 orderByComparator);
5000
5001 if (socialRelation != null) {
5002 return socialRelation;
5003 }
5004
5005 StringBundler msg = new StringBundler(6);
5006
5007 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
5008
5009 msg.append("userId2=");
5010 msg.append(userId2);
5011
5012 msg.append(", type=");
5013 msg.append(type);
5014
5015 msg.append(StringPool.CLOSE_CURLY_BRACE);
5016
5017 throw new NoSuchRelationException(msg.toString());
5018 }
5019
5020
5029 @Override
5030 public SocialRelation fetchByU2_T_Last(long userId2, int type,
5031 OrderByComparator orderByComparator) throws SystemException {
5032 int count = countByU2_T(userId2, type);
5033
5034 if (count == 0) {
5035 return null;
5036 }
5037
5038 List<SocialRelation> list = findByU2_T(userId2, type, count - 1, count,
5039 orderByComparator);
5040
5041 if (!list.isEmpty()) {
5042 return list.get(0);
5043 }
5044
5045 return null;
5046 }
5047
5048
5059 @Override
5060 public SocialRelation[] findByU2_T_PrevAndNext(long relationId,
5061 long userId2, int type, OrderByComparator orderByComparator)
5062 throws NoSuchRelationException, SystemException {
5063 SocialRelation socialRelation = findByPrimaryKey(relationId);
5064
5065 Session session = null;
5066
5067 try {
5068 session = openSession();
5069
5070 SocialRelation[] array = new SocialRelationImpl[3];
5071
5072 array[0] = getByU2_T_PrevAndNext(session, socialRelation, userId2,
5073 type, orderByComparator, true);
5074
5075 array[1] = socialRelation;
5076
5077 array[2] = getByU2_T_PrevAndNext(session, socialRelation, userId2,
5078 type, orderByComparator, false);
5079
5080 return array;
5081 }
5082 catch (Exception e) {
5083 throw processException(e);
5084 }
5085 finally {
5086 closeSession(session);
5087 }
5088 }
5089
5090 protected SocialRelation getByU2_T_PrevAndNext(Session session,
5091 SocialRelation socialRelation, long userId2, int type,
5092 OrderByComparator orderByComparator, boolean previous) {
5093 StringBundler query = null;
5094
5095 if (orderByComparator != null) {
5096 query = new StringBundler(6 +
5097 (orderByComparator.getOrderByFields().length * 6));
5098 }
5099 else {
5100 query = new StringBundler(3);
5101 }
5102
5103 query.append(_SQL_SELECT_SOCIALRELATION_WHERE);
5104
5105 query.append(_FINDER_COLUMN_U2_T_USERID2_2);
5106
5107 query.append(_FINDER_COLUMN_U2_T_TYPE_2);
5108
5109 if (orderByComparator != null) {
5110 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
5111
5112 if (orderByConditionFields.length > 0) {
5113 query.append(WHERE_AND);
5114 }
5115
5116 for (int i = 0; i < orderByConditionFields.length; i++) {
5117 query.append(_ORDER_BY_ENTITY_ALIAS);
5118 query.append(orderByConditionFields[i]);
5119
5120 if ((i + 1) < orderByConditionFields.length) {
5121 if (orderByComparator.isAscending() ^ previous) {
5122 query.append(WHERE_GREATER_THAN_HAS_NEXT);
5123 }
5124 else {
5125 query.append(WHERE_LESSER_THAN_HAS_NEXT);
5126 }
5127 }
5128 else {
5129 if (orderByComparator.isAscending() ^ previous) {
5130 query.append(WHERE_GREATER_THAN);
5131 }
5132 else {
5133 query.append(WHERE_LESSER_THAN);
5134 }
5135 }
5136 }
5137
5138 query.append(ORDER_BY_CLAUSE);
5139
5140 String[] orderByFields = orderByComparator.getOrderByFields();
5141
5142 for (int i = 0; i < orderByFields.length; i++) {
5143 query.append(_ORDER_BY_ENTITY_ALIAS);
5144 query.append(orderByFields[i]);
5145
5146 if ((i + 1) < orderByFields.length) {
5147 if (orderByComparator.isAscending() ^ previous) {
5148 query.append(ORDER_BY_ASC_HAS_NEXT);
5149 }
5150 else {
5151 query.append(ORDER_BY_DESC_HAS_NEXT);
5152 }
5153 }
5154 else {
5155 if (orderByComparator.isAscending() ^ previous) {
5156 query.append(ORDER_BY_ASC);
5157 }
5158 else {
5159 query.append(ORDER_BY_DESC);
5160 }
5161 }
5162 }
5163 }
5164 else {
5165 query.append(SocialRelationModelImpl.ORDER_BY_JPQL);
5166 }
5167
5168 String sql = query.toString();
5169
5170 Query q = session.createQuery(sql);
5171
5172 q.setFirstResult(0);
5173 q.setMaxResults(2);
5174
5175 QueryPos qPos = QueryPos.getInstance(q);
5176
5177 qPos.add(userId2);
5178
5179 qPos.add(type);
5180
5181 if (orderByComparator != null) {
5182 Object[] values = orderByComparator.getOrderByConditionValues(socialRelation);
5183
5184 for (Object value : values) {
5185 qPos.add(value);
5186 }
5187 }
5188
5189 List<SocialRelation> list = q.list();
5190
5191 if (list.size() == 2) {
5192 return list.get(1);
5193 }
5194 else {
5195 return null;
5196 }
5197 }
5198
5199
5206 @Override
5207 public void removeByU2_T(long userId2, int type) throws SystemException {
5208 for (SocialRelation socialRelation : findByU2_T(userId2, type,
5209 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
5210 remove(socialRelation);
5211 }
5212 }
5213
5214
5222 @Override
5223 public int countByU2_T(long userId2, int type) throws SystemException {
5224 FinderPath finderPath = FINDER_PATH_COUNT_BY_U2_T;
5225
5226 Object[] finderArgs = new Object[] { userId2, type };
5227
5228 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
5229 this);
5230
5231 if (count == null) {
5232 StringBundler query = new StringBundler(3);
5233
5234 query.append(_SQL_COUNT_SOCIALRELATION_WHERE);
5235
5236 query.append(_FINDER_COLUMN_U2_T_USERID2_2);
5237
5238 query.append(_FINDER_COLUMN_U2_T_TYPE_2);
5239
5240 String sql = query.toString();
5241
5242 Session session = null;
5243
5244 try {
5245 session = openSession();
5246
5247 Query q = session.createQuery(sql);
5248
5249 QueryPos qPos = QueryPos.getInstance(q);
5250
5251 qPos.add(userId2);
5252
5253 qPos.add(type);
5254
5255 count = (Long)q.uniqueResult();
5256
5257 FinderCacheUtil.putResult(finderPath, finderArgs, count);
5258 }
5259 catch (Exception e) {
5260 FinderCacheUtil.removeResult(finderPath, finderArgs);
5261
5262 throw processException(e);
5263 }
5264 finally {
5265 closeSession(session);
5266 }
5267 }
5268
5269 return count.intValue();
5270 }
5271
5272 private static final String _FINDER_COLUMN_U2_T_USERID2_2 = "socialRelation.userId2 = ? AND ";
5273 private static final String _FINDER_COLUMN_U2_T_TYPE_2 = "socialRelation.type = ?";
5274 public static final FinderPath FINDER_PATH_FETCH_BY_U1_U2_T = new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
5275 SocialRelationModelImpl.FINDER_CACHE_ENABLED,
5276 SocialRelationImpl.class, FINDER_CLASS_NAME_ENTITY,
5277 "fetchByU1_U2_T",
5278 new String[] {
5279 Long.class.getName(), Long.class.getName(),
5280 Integer.class.getName()
5281 },
5282 SocialRelationModelImpl.USERID1_COLUMN_BITMASK |
5283 SocialRelationModelImpl.USERID2_COLUMN_BITMASK |
5284 SocialRelationModelImpl.TYPE_COLUMN_BITMASK);
5285 public static final FinderPath FINDER_PATH_COUNT_BY_U1_U2_T = new FinderPath(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
5286 SocialRelationModelImpl.FINDER_CACHE_ENABLED, Long.class,
5287 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByU1_U2_T",
5288 new String[] {
5289 Long.class.getName(), Long.class.getName(),
5290 Integer.class.getName()
5291 });
5292
5293
5303 @Override
5304 public SocialRelation findByU1_U2_T(long userId1, long userId2, int type)
5305 throws NoSuchRelationException, SystemException {
5306 SocialRelation socialRelation = fetchByU1_U2_T(userId1, userId2, type);
5307
5308 if (socialRelation == null) {
5309 StringBundler msg = new StringBundler(8);
5310
5311 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
5312
5313 msg.append("userId1=");
5314 msg.append(userId1);
5315
5316 msg.append(", userId2=");
5317 msg.append(userId2);
5318
5319 msg.append(", type=");
5320 msg.append(type);
5321
5322 msg.append(StringPool.CLOSE_CURLY_BRACE);
5323
5324 if (_log.isWarnEnabled()) {
5325 _log.warn(msg.toString());
5326 }
5327
5328 throw new NoSuchRelationException(msg.toString());
5329 }
5330
5331 return socialRelation;
5332 }
5333
5334
5343 @Override
5344 public SocialRelation fetchByU1_U2_T(long userId1, long userId2, int type)
5345 throws SystemException {
5346 return fetchByU1_U2_T(userId1, userId2, type, true);
5347 }
5348
5349
5359 @Override
5360 public SocialRelation fetchByU1_U2_T(long userId1, long userId2, int type,
5361 boolean retrieveFromCache) throws SystemException {
5362 Object[] finderArgs = new Object[] { userId1, userId2, type };
5363
5364 Object result = null;
5365
5366 if (retrieveFromCache) {
5367 result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_U1_U2_T,
5368 finderArgs, this);
5369 }
5370
5371 if (result instanceof SocialRelation) {
5372 SocialRelation socialRelation = (SocialRelation)result;
5373
5374 if ((userId1 != socialRelation.getUserId1()) ||
5375 (userId2 != socialRelation.getUserId2()) ||
5376 (type != socialRelation.getType())) {
5377 result = null;
5378 }
5379 }
5380
5381 if (result == null) {
5382 StringBundler query = new StringBundler(5);
5383
5384 query.append(_SQL_SELECT_SOCIALRELATION_WHERE);
5385
5386 query.append(_FINDER_COLUMN_U1_U2_T_USERID1_2);
5387
5388 query.append(_FINDER_COLUMN_U1_U2_T_USERID2_2);
5389
5390 query.append(_FINDER_COLUMN_U1_U2_T_TYPE_2);
5391
5392 String sql = query.toString();
5393
5394 Session session = null;
5395
5396 try {
5397 session = openSession();
5398
5399 Query q = session.createQuery(sql);
5400
5401 QueryPos qPos = QueryPos.getInstance(q);
5402
5403 qPos.add(userId1);
5404
5405 qPos.add(userId2);
5406
5407 qPos.add(type);
5408
5409 List<SocialRelation> list = q.list();
5410
5411 if (list.isEmpty()) {
5412 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_U1_U2_T,
5413 finderArgs, list);
5414 }
5415 else {
5416 SocialRelation socialRelation = list.get(0);
5417
5418 result = socialRelation;
5419
5420 cacheResult(socialRelation);
5421
5422 if ((socialRelation.getUserId1() != userId1) ||
5423 (socialRelation.getUserId2() != userId2) ||
5424 (socialRelation.getType() != type)) {
5425 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_U1_U2_T,
5426 finderArgs, socialRelation);
5427 }
5428 }
5429 }
5430 catch (Exception e) {
5431 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_U1_U2_T,
5432 finderArgs);
5433
5434 throw processException(e);
5435 }
5436 finally {
5437 closeSession(session);
5438 }
5439 }
5440
5441 if (result instanceof List<?>) {
5442 return null;
5443 }
5444 else {
5445 return (SocialRelation)result;
5446 }
5447 }
5448
5449
5458 @Override
5459 public SocialRelation removeByU1_U2_T(long userId1, long userId2, int type)
5460 throws NoSuchRelationException, SystemException {
5461 SocialRelation socialRelation = findByU1_U2_T(userId1, userId2, type);
5462
5463 return remove(socialRelation);
5464 }
5465
5466
5475 @Override
5476 public int countByU1_U2_T(long userId1, long userId2, int type)
5477 throws SystemException {
5478 FinderPath finderPath = FINDER_PATH_COUNT_BY_U1_U2_T;
5479
5480 Object[] finderArgs = new Object[] { userId1, userId2, type };
5481
5482 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
5483 this);
5484
5485 if (count == null) {
5486 StringBundler query = new StringBundler(4);
5487
5488 query.append(_SQL_COUNT_SOCIALRELATION_WHERE);
5489
5490 query.append(_FINDER_COLUMN_U1_U2_T_USERID1_2);
5491
5492 query.append(_FINDER_COLUMN_U1_U2_T_USERID2_2);
5493
5494 query.append(_FINDER_COLUMN_U1_U2_T_TYPE_2);
5495
5496 String sql = query.toString();
5497
5498 Session session = null;
5499
5500 try {
5501 session = openSession();
5502
5503 Query q = session.createQuery(sql);
5504
5505 QueryPos qPos = QueryPos.getInstance(q);
5506
5507 qPos.add(userId1);
5508
5509 qPos.add(userId2);
5510
5511 qPos.add(type);
5512
5513 count = (Long)q.uniqueResult();
5514
5515 FinderCacheUtil.putResult(finderPath, finderArgs, count);
5516 }
5517 catch (Exception e) {
5518 FinderCacheUtil.removeResult(finderPath, finderArgs);
5519
5520 throw processException(e);
5521 }
5522 finally {
5523 closeSession(session);
5524 }
5525 }
5526
5527 return count.intValue();
5528 }
5529
5530 private static final String _FINDER_COLUMN_U1_U2_T_USERID1_2 = "socialRelation.userId1 = ? AND ";
5531 private static final String _FINDER_COLUMN_U1_U2_T_USERID2_2 = "socialRelation.userId2 = ? AND ";
5532 private static final String _FINDER_COLUMN_U1_U2_T_TYPE_2 = "socialRelation.type = ?";
5533
5534
5539 @Override
5540 public void cacheResult(SocialRelation socialRelation) {
5541 EntityCacheUtil.putResult(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
5542 SocialRelationImpl.class, socialRelation.getPrimaryKey(),
5543 socialRelation);
5544
5545 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_U1_U2_T,
5546 new Object[] {
5547 socialRelation.getUserId1(), socialRelation.getUserId2(),
5548 socialRelation.getType()
5549 }, socialRelation);
5550
5551 socialRelation.resetOriginalValues();
5552 }
5553
5554
5559 @Override
5560 public void cacheResult(List<SocialRelation> socialRelations) {
5561 for (SocialRelation socialRelation : socialRelations) {
5562 if (EntityCacheUtil.getResult(
5563 SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
5564 SocialRelationImpl.class, socialRelation.getPrimaryKey()) == null) {
5565 cacheResult(socialRelation);
5566 }
5567 else {
5568 socialRelation.resetOriginalValues();
5569 }
5570 }
5571 }
5572
5573
5580 @Override
5581 public void clearCache() {
5582 if (_HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE) {
5583 CacheRegistryUtil.clear(SocialRelationImpl.class.getName());
5584 }
5585
5586 EntityCacheUtil.clearCache(SocialRelationImpl.class.getName());
5587
5588 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
5589 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
5590 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
5591 }
5592
5593
5600 @Override
5601 public void clearCache(SocialRelation socialRelation) {
5602 EntityCacheUtil.removeResult(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
5603 SocialRelationImpl.class, socialRelation.getPrimaryKey());
5604
5605 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
5606 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
5607
5608 clearUniqueFindersCache(socialRelation);
5609 }
5610
5611 @Override
5612 public void clearCache(List<SocialRelation> socialRelations) {
5613 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
5614 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
5615
5616 for (SocialRelation socialRelation : socialRelations) {
5617 EntityCacheUtil.removeResult(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
5618 SocialRelationImpl.class, socialRelation.getPrimaryKey());
5619
5620 clearUniqueFindersCache(socialRelation);
5621 }
5622 }
5623
5624 protected void cacheUniqueFindersCache(SocialRelation socialRelation) {
5625 if (socialRelation.isNew()) {
5626 Object[] args = new Object[] {
5627 socialRelation.getUserId1(), socialRelation.getUserId2(),
5628 socialRelation.getType()
5629 };
5630
5631 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_U1_U2_T, args,
5632 Long.valueOf(1));
5633 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_U1_U2_T, args,
5634 socialRelation);
5635 }
5636 else {
5637 SocialRelationModelImpl socialRelationModelImpl = (SocialRelationModelImpl)socialRelation;
5638
5639 if ((socialRelationModelImpl.getColumnBitmask() &
5640 FINDER_PATH_FETCH_BY_U1_U2_T.getColumnBitmask()) != 0) {
5641 Object[] args = new Object[] {
5642 socialRelation.getUserId1(), socialRelation.getUserId2(),
5643 socialRelation.getType()
5644 };
5645
5646 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_U1_U2_T, args,
5647 Long.valueOf(1));
5648 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_U1_U2_T, args,
5649 socialRelation);
5650 }
5651 }
5652 }
5653
5654 protected void clearUniqueFindersCache(SocialRelation socialRelation) {
5655 SocialRelationModelImpl socialRelationModelImpl = (SocialRelationModelImpl)socialRelation;
5656
5657 Object[] args = new Object[] {
5658 socialRelation.getUserId1(), socialRelation.getUserId2(),
5659 socialRelation.getType()
5660 };
5661
5662 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_U1_U2_T, args);
5663 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_U1_U2_T, args);
5664
5665 if ((socialRelationModelImpl.getColumnBitmask() &
5666 FINDER_PATH_FETCH_BY_U1_U2_T.getColumnBitmask()) != 0) {
5667 args = new Object[] {
5668 socialRelationModelImpl.getOriginalUserId1(),
5669 socialRelationModelImpl.getOriginalUserId2(),
5670 socialRelationModelImpl.getOriginalType()
5671 };
5672
5673 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_U1_U2_T, args);
5674 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_U1_U2_T, args);
5675 }
5676 }
5677
5678
5684 @Override
5685 public SocialRelation create(long relationId) {
5686 SocialRelation socialRelation = new SocialRelationImpl();
5687
5688 socialRelation.setNew(true);
5689 socialRelation.setPrimaryKey(relationId);
5690
5691 String uuid = PortalUUIDUtil.generate();
5692
5693 socialRelation.setUuid(uuid);
5694
5695 return socialRelation;
5696 }
5697
5698
5706 @Override
5707 public SocialRelation remove(long relationId)
5708 throws NoSuchRelationException, SystemException {
5709 return remove((Serializable)relationId);
5710 }
5711
5712
5720 @Override
5721 public SocialRelation remove(Serializable primaryKey)
5722 throws NoSuchRelationException, SystemException {
5723 Session session = null;
5724
5725 try {
5726 session = openSession();
5727
5728 SocialRelation socialRelation = (SocialRelation)session.get(SocialRelationImpl.class,
5729 primaryKey);
5730
5731 if (socialRelation == null) {
5732 if (_log.isWarnEnabled()) {
5733 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey);
5734 }
5735
5736 throw new NoSuchRelationException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
5737 primaryKey);
5738 }
5739
5740 return remove(socialRelation);
5741 }
5742 catch (NoSuchRelationException nsee) {
5743 throw nsee;
5744 }
5745 catch (Exception e) {
5746 throw processException(e);
5747 }
5748 finally {
5749 closeSession(session);
5750 }
5751 }
5752
5753 @Override
5754 protected SocialRelation removeImpl(SocialRelation socialRelation)
5755 throws SystemException {
5756 socialRelation = toUnwrappedModel(socialRelation);
5757
5758 Session session = null;
5759
5760 try {
5761 session = openSession();
5762
5763 if (!session.contains(socialRelation)) {
5764 socialRelation = (SocialRelation)session.get(SocialRelationImpl.class,
5765 socialRelation.getPrimaryKeyObj());
5766 }
5767
5768 if (socialRelation != null) {
5769 session.delete(socialRelation);
5770 }
5771 }
5772 catch (Exception e) {
5773 throw processException(e);
5774 }
5775 finally {
5776 closeSession(session);
5777 }
5778
5779 if (socialRelation != null) {
5780 clearCache(socialRelation);
5781 }
5782
5783 return socialRelation;
5784 }
5785
5786 @Override
5787 public SocialRelation updateImpl(
5788 com.liferay.portlet.social.model.SocialRelation socialRelation)
5789 throws SystemException {
5790 socialRelation = toUnwrappedModel(socialRelation);
5791
5792 boolean isNew = socialRelation.isNew();
5793
5794 SocialRelationModelImpl socialRelationModelImpl = (SocialRelationModelImpl)socialRelation;
5795
5796 if (Validator.isNull(socialRelation.getUuid())) {
5797 String uuid = PortalUUIDUtil.generate();
5798
5799 socialRelation.setUuid(uuid);
5800 }
5801
5802 Session session = null;
5803
5804 try {
5805 session = openSession();
5806
5807 if (socialRelation.isNew()) {
5808 session.save(socialRelation);
5809
5810 socialRelation.setNew(false);
5811 }
5812 else {
5813 session.merge(socialRelation);
5814 }
5815 }
5816 catch (Exception e) {
5817 throw processException(e);
5818 }
5819 finally {
5820 closeSession(session);
5821 }
5822
5823 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
5824
5825 if (isNew || !SocialRelationModelImpl.COLUMN_BITMASK_ENABLED) {
5826 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
5827 }
5828
5829 else {
5830 if ((socialRelationModelImpl.getColumnBitmask() &
5831 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID.getColumnBitmask()) != 0) {
5832 Object[] args = new Object[] {
5833 socialRelationModelImpl.getOriginalUuid()
5834 };
5835
5836 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID, args);
5837 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID,
5838 args);
5839
5840 args = new Object[] { socialRelationModelImpl.getUuid() };
5841
5842 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID, args);
5843 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID,
5844 args);
5845 }
5846
5847 if ((socialRelationModelImpl.getColumnBitmask() &
5848 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C.getColumnBitmask()) != 0) {
5849 Object[] args = new Object[] {
5850 socialRelationModelImpl.getOriginalUuid(),
5851 socialRelationModelImpl.getOriginalCompanyId()
5852 };
5853
5854 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID_C, args);
5855 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C,
5856 args);
5857
5858 args = new Object[] {
5859 socialRelationModelImpl.getUuid(),
5860 socialRelationModelImpl.getCompanyId()
5861 };
5862
5863 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID_C, args);
5864 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C,
5865 args);
5866 }
5867
5868 if ((socialRelationModelImpl.getColumnBitmask() &
5869 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_COMPANYID.getColumnBitmask()) != 0) {
5870 Object[] args = new Object[] {
5871 socialRelationModelImpl.getOriginalCompanyId()
5872 };
5873
5874 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_COMPANYID,
5875 args);
5876 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_COMPANYID,
5877 args);
5878
5879 args = new Object[] { socialRelationModelImpl.getCompanyId() };
5880
5881 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_COMPANYID,
5882 args);
5883 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_COMPANYID,
5884 args);
5885 }
5886
5887 if ((socialRelationModelImpl.getColumnBitmask() &
5888 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_USERID1.getColumnBitmask()) != 0) {
5889 Object[] args = new Object[] {
5890 socialRelationModelImpl.getOriginalUserId1()
5891 };
5892
5893 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_USERID1, args);
5894 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_USERID1,
5895 args);
5896
5897 args = new Object[] { socialRelationModelImpl.getUserId1() };
5898
5899 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_USERID1, args);
5900 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_USERID1,
5901 args);
5902 }
5903
5904 if ((socialRelationModelImpl.getColumnBitmask() &
5905 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_USERID2.getColumnBitmask()) != 0) {
5906 Object[] args = new Object[] {
5907 socialRelationModelImpl.getOriginalUserId2()
5908 };
5909
5910 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_USERID2, args);
5911 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_USERID2,
5912 args);
5913
5914 args = new Object[] { socialRelationModelImpl.getUserId2() };
5915
5916 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_USERID2, args);
5917 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_USERID2,
5918 args);
5919 }
5920
5921 if ((socialRelationModelImpl.getColumnBitmask() &
5922 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_TYPE.getColumnBitmask()) != 0) {
5923 Object[] args = new Object[] {
5924 socialRelationModelImpl.getOriginalType()
5925 };
5926
5927 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_TYPE, args);
5928 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_TYPE,
5929 args);
5930
5931 args = new Object[] { socialRelationModelImpl.getType() };
5932
5933 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_TYPE, args);
5934 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_TYPE,
5935 args);
5936 }
5937
5938 if ((socialRelationModelImpl.getColumnBitmask() &
5939 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_C_T.getColumnBitmask()) != 0) {
5940 Object[] args = new Object[] {
5941 socialRelationModelImpl.getOriginalCompanyId(),
5942 socialRelationModelImpl.getOriginalType()
5943 };
5944
5945 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_C_T, args);
5946 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_C_T,
5947 args);
5948
5949 args = new Object[] {
5950 socialRelationModelImpl.getCompanyId(),
5951 socialRelationModelImpl.getType()
5952 };
5953
5954 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_C_T, args);
5955 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_C_T,
5956 args);
5957 }
5958
5959 if ((socialRelationModelImpl.getColumnBitmask() &
5960 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_U1_U2.getColumnBitmask()) != 0) {
5961 Object[] args = new Object[] {
5962 socialRelationModelImpl.getOriginalUserId1(),
5963 socialRelationModelImpl.getOriginalUserId2()
5964 };
5965
5966 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_U1_U2, args);
5967 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_U1_U2,
5968 args);
5969
5970 args = new Object[] {
5971 socialRelationModelImpl.getUserId1(),
5972 socialRelationModelImpl.getUserId2()
5973 };
5974
5975 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_U1_U2, args);
5976 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_U1_U2,
5977 args);
5978 }
5979
5980 if ((socialRelationModelImpl.getColumnBitmask() &
5981 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_U1_T.getColumnBitmask()) != 0) {
5982 Object[] args = new Object[] {
5983 socialRelationModelImpl.getOriginalUserId1(),
5984 socialRelationModelImpl.getOriginalType()
5985 };
5986
5987 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_U1_T, args);
5988 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_U1_T,
5989 args);
5990
5991 args = new Object[] {
5992 socialRelationModelImpl.getUserId1(),
5993 socialRelationModelImpl.getType()
5994 };
5995
5996 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_U1_T, args);
5997 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_U1_T,
5998 args);
5999 }
6000
6001 if ((socialRelationModelImpl.getColumnBitmask() &
6002 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_U2_T.getColumnBitmask()) != 0) {
6003 Object[] args = new Object[] {
6004 socialRelationModelImpl.getOriginalUserId2(),
6005 socialRelationModelImpl.getOriginalType()
6006 };
6007
6008 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_U2_T, args);
6009 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_U2_T,
6010 args);
6011
6012 args = new Object[] {
6013 socialRelationModelImpl.getUserId2(),
6014 socialRelationModelImpl.getType()
6015 };
6016
6017 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_U2_T, args);
6018 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_U2_T,
6019 args);
6020 }
6021 }
6022
6023 EntityCacheUtil.putResult(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
6024 SocialRelationImpl.class, socialRelation.getPrimaryKey(),
6025 socialRelation);
6026
6027 clearUniqueFindersCache(socialRelation);
6028 cacheUniqueFindersCache(socialRelation);
6029
6030 return socialRelation;
6031 }
6032
6033 protected SocialRelation toUnwrappedModel(SocialRelation socialRelation) {
6034 if (socialRelation instanceof SocialRelationImpl) {
6035 return socialRelation;
6036 }
6037
6038 SocialRelationImpl socialRelationImpl = new SocialRelationImpl();
6039
6040 socialRelationImpl.setNew(socialRelation.isNew());
6041 socialRelationImpl.setPrimaryKey(socialRelation.getPrimaryKey());
6042
6043 socialRelationImpl.setUuid(socialRelation.getUuid());
6044 socialRelationImpl.setRelationId(socialRelation.getRelationId());
6045 socialRelationImpl.setCompanyId(socialRelation.getCompanyId());
6046 socialRelationImpl.setCreateDate(socialRelation.getCreateDate());
6047 socialRelationImpl.setUserId1(socialRelation.getUserId1());
6048 socialRelationImpl.setUserId2(socialRelation.getUserId2());
6049 socialRelationImpl.setType(socialRelation.getType());
6050
6051 return socialRelationImpl;
6052 }
6053
6054
6062 @Override
6063 public SocialRelation findByPrimaryKey(Serializable primaryKey)
6064 throws NoSuchRelationException, SystemException {
6065 SocialRelation socialRelation = fetchByPrimaryKey(primaryKey);
6066
6067 if (socialRelation == null) {
6068 if (_log.isWarnEnabled()) {
6069 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey);
6070 }
6071
6072 throw new NoSuchRelationException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
6073 primaryKey);
6074 }
6075
6076 return socialRelation;
6077 }
6078
6079
6087 @Override
6088 public SocialRelation findByPrimaryKey(long relationId)
6089 throws NoSuchRelationException, SystemException {
6090 return findByPrimaryKey((Serializable)relationId);
6091 }
6092
6093
6100 @Override
6101 public SocialRelation fetchByPrimaryKey(Serializable primaryKey)
6102 throws SystemException {
6103 SocialRelation socialRelation = (SocialRelation)EntityCacheUtil.getResult(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
6104 SocialRelationImpl.class, primaryKey);
6105
6106 if (socialRelation == _nullSocialRelation) {
6107 return null;
6108 }
6109
6110 if (socialRelation == null) {
6111 Session session = null;
6112
6113 try {
6114 session = openSession();
6115
6116 socialRelation = (SocialRelation)session.get(SocialRelationImpl.class,
6117 primaryKey);
6118
6119 if (socialRelation != null) {
6120 cacheResult(socialRelation);
6121 }
6122 else {
6123 EntityCacheUtil.putResult(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
6124 SocialRelationImpl.class, primaryKey,
6125 _nullSocialRelation);
6126 }
6127 }
6128 catch (Exception e) {
6129 EntityCacheUtil.removeResult(SocialRelationModelImpl.ENTITY_CACHE_ENABLED,
6130 SocialRelationImpl.class, primaryKey);
6131
6132 throw processException(e);
6133 }
6134 finally {
6135 closeSession(session);
6136 }
6137 }
6138
6139 return socialRelation;
6140 }
6141
6142
6149 @Override
6150 public SocialRelation fetchByPrimaryKey(long relationId)
6151 throws SystemException {
6152 return fetchByPrimaryKey((Serializable)relationId);
6153 }
6154
6155
6161 @Override
6162 public List<SocialRelation> findAll() throws SystemException {
6163 return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
6164 }
6165
6166
6178 @Override
6179 public List<SocialRelation> findAll(int start, int end)
6180 throws SystemException {
6181 return findAll(start, end, null);
6182 }
6183
6184
6197 @Override
6198 public List<SocialRelation> findAll(int start, int end,
6199 OrderByComparator orderByComparator) throws SystemException {
6200 boolean pagination = true;
6201 FinderPath finderPath = null;
6202 Object[] finderArgs = null;
6203
6204 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
6205 (orderByComparator == null)) {
6206 pagination = false;
6207 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL;
6208 finderArgs = FINDER_ARGS_EMPTY;
6209 }
6210 else {
6211 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_ALL;
6212 finderArgs = new Object[] { start, end, orderByComparator };
6213 }
6214
6215 List<SocialRelation> list = (List<SocialRelation>)FinderCacheUtil.getResult(finderPath,
6216 finderArgs, this);
6217
6218 if (list == null) {
6219 StringBundler query = null;
6220 String sql = null;
6221
6222 if (orderByComparator != null) {
6223 query = new StringBundler(2 +
6224 (orderByComparator.getOrderByFields().length * 3));
6225
6226 query.append(_SQL_SELECT_SOCIALRELATION);
6227
6228 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
6229 orderByComparator);
6230
6231 sql = query.toString();
6232 }
6233 else {
6234 sql = _SQL_SELECT_SOCIALRELATION;
6235
6236 if (pagination) {
6237 sql = sql.concat(SocialRelationModelImpl.ORDER_BY_JPQL);
6238 }
6239 }
6240
6241 Session session = null;
6242
6243 try {
6244 session = openSession();
6245
6246 Query q = session.createQuery(sql);
6247
6248 if (!pagination) {
6249 list = (List<SocialRelation>)QueryUtil.list(q,
6250 getDialect(), start, end, false);
6251
6252 Collections.sort(list);
6253
6254 list = new UnmodifiableList<SocialRelation>(list);
6255 }
6256 else {
6257 list = (List<SocialRelation>)QueryUtil.list(q,
6258 getDialect(), start, end);
6259 }
6260
6261 cacheResult(list);
6262
6263 FinderCacheUtil.putResult(finderPath, finderArgs, list);
6264 }
6265 catch (Exception e) {
6266 FinderCacheUtil.removeResult(finderPath, finderArgs);
6267
6268 throw processException(e);
6269 }
6270 finally {
6271 closeSession(session);
6272 }
6273 }
6274
6275 return list;
6276 }
6277
6278
6283 @Override
6284 public void removeAll() throws SystemException {
6285 for (SocialRelation socialRelation : findAll()) {
6286 remove(socialRelation);
6287 }
6288 }
6289
6290
6296 @Override
6297 public int countAll() throws SystemException {
6298 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
6299 FINDER_ARGS_EMPTY, this);
6300
6301 if (count == null) {
6302 Session session = null;
6303
6304 try {
6305 session = openSession();
6306
6307 Query q = session.createQuery(_SQL_COUNT_SOCIALRELATION);
6308
6309 count = (Long)q.uniqueResult();
6310
6311 FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL,
6312 FINDER_ARGS_EMPTY, count);
6313 }
6314 catch (Exception e) {
6315 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_ALL,
6316 FINDER_ARGS_EMPTY);
6317
6318 throw processException(e);
6319 }
6320 finally {
6321 closeSession(session);
6322 }
6323 }
6324
6325 return count.intValue();
6326 }
6327
6328 @Override
6329 protected Set<String> getBadColumnNames() {
6330 return _badColumnNames;
6331 }
6332
6333
6336 public void afterPropertiesSet() {
6337 String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
6338 com.liferay.portal.util.PropsUtil.get(
6339 "value.object.listener.com.liferay.portlet.social.model.SocialRelation")));
6340
6341 if (listenerClassNames.length > 0) {
6342 try {
6343 List<ModelListener<SocialRelation>> listenersList = new ArrayList<ModelListener<SocialRelation>>();
6344
6345 for (String listenerClassName : listenerClassNames) {
6346 listenersList.add((ModelListener<SocialRelation>)InstanceFactory.newInstance(
6347 getClassLoader(), listenerClassName));
6348 }
6349
6350 listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
6351 }
6352 catch (Exception e) {
6353 _log.error(e);
6354 }
6355 }
6356 }
6357
6358 public void destroy() {
6359 EntityCacheUtil.removeCache(SocialRelationImpl.class.getName());
6360 FinderCacheUtil.removeCache(FINDER_CLASS_NAME_ENTITY);
6361 FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
6362 FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
6363 }
6364
6365 private static final String _SQL_SELECT_SOCIALRELATION = "SELECT socialRelation FROM SocialRelation socialRelation";
6366 private static final String _SQL_SELECT_SOCIALRELATION_WHERE = "SELECT socialRelation FROM SocialRelation socialRelation WHERE ";
6367 private static final String _SQL_COUNT_SOCIALRELATION = "SELECT COUNT(socialRelation) FROM SocialRelation socialRelation";
6368 private static final String _SQL_COUNT_SOCIALRELATION_WHERE = "SELECT COUNT(socialRelation) FROM SocialRelation socialRelation WHERE ";
6369 private static final String _ORDER_BY_ENTITY_ALIAS = "socialRelation.";
6370 private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No SocialRelation exists with the primary key ";
6371 private static final String _NO_SUCH_ENTITY_WITH_KEY = "No SocialRelation exists with the key {";
6372 private static final boolean _HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE = com.liferay.portal.util.PropsValues.HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE;
6373 private static Log _log = LogFactoryUtil.getLog(SocialRelationPersistenceImpl.class);
6374 private static Set<String> _badColumnNames = SetUtil.fromArray(new String[] {
6375 "uuid", "type"
6376 });
6377 private static SocialRelation _nullSocialRelation = new SocialRelationImpl() {
6378 @Override
6379 public Object clone() {
6380 return this;
6381 }
6382
6383 @Override
6384 public CacheModel<SocialRelation> toCacheModel() {
6385 return _nullSocialRelationCacheModel;
6386 }
6387 };
6388
6389 private static CacheModel<SocialRelation> _nullSocialRelationCacheModel = new CacheModel<SocialRelation>() {
6390 @Override
6391 public SocialRelation toEntityModel() {
6392 return _nullSocialRelation;
6393 }
6394 };
6395 }