001
014
015 package com.liferay.portlet.expando.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.model.CacheModel;
038 import com.liferay.portal.model.ModelListener;
039 import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
040
041 import com.liferay.portlet.expando.NoSuchValueException;
042 import com.liferay.portlet.expando.model.ExpandoValue;
043 import com.liferay.portlet.expando.model.impl.ExpandoValueImpl;
044 import com.liferay.portlet.expando.model.impl.ExpandoValueModelImpl;
045
046 import java.io.Serializable;
047
048 import java.util.ArrayList;
049 import java.util.Collections;
050 import java.util.List;
051 import java.util.Set;
052
053
065 public class ExpandoValuePersistenceImpl extends BasePersistenceImpl<ExpandoValue>
066 implements ExpandoValuePersistence {
067
072 public static final String FINDER_CLASS_NAME_ENTITY = ExpandoValueImpl.class.getName();
073 public static final String FINDER_CLASS_NAME_LIST_WITH_PAGINATION = FINDER_CLASS_NAME_ENTITY +
074 ".List1";
075 public static final String FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION = FINDER_CLASS_NAME_ENTITY +
076 ".List2";
077 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_ALL = new FinderPath(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
078 ExpandoValueModelImpl.FINDER_CACHE_ENABLED, ExpandoValueImpl.class,
079 FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findAll", new String[0]);
080 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL = new FinderPath(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
081 ExpandoValueModelImpl.FINDER_CACHE_ENABLED, ExpandoValueImpl.class,
082 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findAll", new String[0]);
083 public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
084 ExpandoValueModelImpl.FINDER_CACHE_ENABLED, Long.class,
085 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countAll", new String[0]);
086 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_TABLEID = new FinderPath(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
087 ExpandoValueModelImpl.FINDER_CACHE_ENABLED, ExpandoValueImpl.class,
088 FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByTableId",
089 new String[] {
090 Long.class.getName(),
091
092 Integer.class.getName(), Integer.class.getName(),
093 OrderByComparator.class.getName()
094 });
095 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_TABLEID =
096 new FinderPath(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
097 ExpandoValueModelImpl.FINDER_CACHE_ENABLED, ExpandoValueImpl.class,
098 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByTableId",
099 new String[] { Long.class.getName() },
100 ExpandoValueModelImpl.TABLEID_COLUMN_BITMASK |
101 ExpandoValueModelImpl.ROWID_COLUMN_BITMASK |
102 ExpandoValueModelImpl.COLUMNID_COLUMN_BITMASK);
103 public static final FinderPath FINDER_PATH_COUNT_BY_TABLEID = new FinderPath(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
104 ExpandoValueModelImpl.FINDER_CACHE_ENABLED, Long.class,
105 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByTableId",
106 new String[] { Long.class.getName() });
107
108
115 @Override
116 public List<ExpandoValue> findByTableId(long tableId)
117 throws SystemException {
118 return findByTableId(tableId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
119 }
120
121
134 @Override
135 public List<ExpandoValue> findByTableId(long tableId, int start, int end)
136 throws SystemException {
137 return findByTableId(tableId, start, end, null);
138 }
139
140
154 @Override
155 public List<ExpandoValue> findByTableId(long tableId, int start, int end,
156 OrderByComparator orderByComparator) throws SystemException {
157 boolean pagination = true;
158 FinderPath finderPath = null;
159 Object[] finderArgs = null;
160
161 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
162 (orderByComparator == null)) {
163 pagination = false;
164 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_TABLEID;
165 finderArgs = new Object[] { tableId };
166 }
167 else {
168 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_TABLEID;
169 finderArgs = new Object[] { tableId, start, end, orderByComparator };
170 }
171
172 List<ExpandoValue> list = (List<ExpandoValue>)FinderCacheUtil.getResult(finderPath,
173 finderArgs, this);
174
175 if ((list != null) && !list.isEmpty()) {
176 for (ExpandoValue expandoValue : list) {
177 if ((tableId != expandoValue.getTableId())) {
178 list = null;
179
180 break;
181 }
182 }
183 }
184
185 if (list == null) {
186 StringBundler query = null;
187
188 if (orderByComparator != null) {
189 query = new StringBundler(3 +
190 (orderByComparator.getOrderByFields().length * 3));
191 }
192 else {
193 query = new StringBundler(3);
194 }
195
196 query.append(_SQL_SELECT_EXPANDOVALUE_WHERE);
197
198 query.append(_FINDER_COLUMN_TABLEID_TABLEID_2);
199
200 if (orderByComparator != null) {
201 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
202 orderByComparator);
203 }
204 else
205 if (pagination) {
206 query.append(ExpandoValueModelImpl.ORDER_BY_JPQL);
207 }
208
209 String sql = query.toString();
210
211 Session session = null;
212
213 try {
214 session = openSession();
215
216 Query q = session.createQuery(sql);
217
218 QueryPos qPos = QueryPos.getInstance(q);
219
220 qPos.add(tableId);
221
222 if (!pagination) {
223 list = (List<ExpandoValue>)QueryUtil.list(q, getDialect(),
224 start, end, false);
225
226 Collections.sort(list);
227
228 list = new UnmodifiableList<ExpandoValue>(list);
229 }
230 else {
231 list = (List<ExpandoValue>)QueryUtil.list(q, getDialect(),
232 start, end);
233 }
234
235 cacheResult(list);
236
237 FinderCacheUtil.putResult(finderPath, finderArgs, list);
238 }
239 catch (Exception e) {
240 FinderCacheUtil.removeResult(finderPath, finderArgs);
241
242 throw processException(e);
243 }
244 finally {
245 closeSession(session);
246 }
247 }
248
249 return list;
250 }
251
252
261 @Override
262 public ExpandoValue findByTableId_First(long tableId,
263 OrderByComparator orderByComparator)
264 throws NoSuchValueException, SystemException {
265 ExpandoValue expandoValue = fetchByTableId_First(tableId,
266 orderByComparator);
267
268 if (expandoValue != null) {
269 return expandoValue;
270 }
271
272 StringBundler msg = new StringBundler(4);
273
274 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
275
276 msg.append("tableId=");
277 msg.append(tableId);
278
279 msg.append(StringPool.CLOSE_CURLY_BRACE);
280
281 throw new NoSuchValueException(msg.toString());
282 }
283
284
292 @Override
293 public ExpandoValue fetchByTableId_First(long tableId,
294 OrderByComparator orderByComparator) throws SystemException {
295 List<ExpandoValue> list = findByTableId(tableId, 0, 1, orderByComparator);
296
297 if (!list.isEmpty()) {
298 return list.get(0);
299 }
300
301 return null;
302 }
303
304
313 @Override
314 public ExpandoValue findByTableId_Last(long tableId,
315 OrderByComparator orderByComparator)
316 throws NoSuchValueException, SystemException {
317 ExpandoValue expandoValue = fetchByTableId_Last(tableId,
318 orderByComparator);
319
320 if (expandoValue != null) {
321 return expandoValue;
322 }
323
324 StringBundler msg = new StringBundler(4);
325
326 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
327
328 msg.append("tableId=");
329 msg.append(tableId);
330
331 msg.append(StringPool.CLOSE_CURLY_BRACE);
332
333 throw new NoSuchValueException(msg.toString());
334 }
335
336
344 @Override
345 public ExpandoValue fetchByTableId_Last(long tableId,
346 OrderByComparator orderByComparator) throws SystemException {
347 int count = countByTableId(tableId);
348
349 if (count == 0) {
350 return null;
351 }
352
353 List<ExpandoValue> list = findByTableId(tableId, count - 1, count,
354 orderByComparator);
355
356 if (!list.isEmpty()) {
357 return list.get(0);
358 }
359
360 return null;
361 }
362
363
373 @Override
374 public ExpandoValue[] findByTableId_PrevAndNext(long valueId, long tableId,
375 OrderByComparator orderByComparator)
376 throws NoSuchValueException, SystemException {
377 ExpandoValue expandoValue = findByPrimaryKey(valueId);
378
379 Session session = null;
380
381 try {
382 session = openSession();
383
384 ExpandoValue[] array = new ExpandoValueImpl[3];
385
386 array[0] = getByTableId_PrevAndNext(session, expandoValue, tableId,
387 orderByComparator, true);
388
389 array[1] = expandoValue;
390
391 array[2] = getByTableId_PrevAndNext(session, expandoValue, tableId,
392 orderByComparator, false);
393
394 return array;
395 }
396 catch (Exception e) {
397 throw processException(e);
398 }
399 finally {
400 closeSession(session);
401 }
402 }
403
404 protected ExpandoValue getByTableId_PrevAndNext(Session session,
405 ExpandoValue expandoValue, long tableId,
406 OrderByComparator orderByComparator, boolean previous) {
407 StringBundler query = null;
408
409 if (orderByComparator != null) {
410 query = new StringBundler(6 +
411 (orderByComparator.getOrderByFields().length * 6));
412 }
413 else {
414 query = new StringBundler(3);
415 }
416
417 query.append(_SQL_SELECT_EXPANDOVALUE_WHERE);
418
419 query.append(_FINDER_COLUMN_TABLEID_TABLEID_2);
420
421 if (orderByComparator != null) {
422 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
423
424 if (orderByConditionFields.length > 0) {
425 query.append(WHERE_AND);
426 }
427
428 for (int i = 0; i < orderByConditionFields.length; i++) {
429 query.append(_ORDER_BY_ENTITY_ALIAS);
430 query.append(orderByConditionFields[i]);
431
432 if ((i + 1) < orderByConditionFields.length) {
433 if (orderByComparator.isAscending() ^ previous) {
434 query.append(WHERE_GREATER_THAN_HAS_NEXT);
435 }
436 else {
437 query.append(WHERE_LESSER_THAN_HAS_NEXT);
438 }
439 }
440 else {
441 if (orderByComparator.isAscending() ^ previous) {
442 query.append(WHERE_GREATER_THAN);
443 }
444 else {
445 query.append(WHERE_LESSER_THAN);
446 }
447 }
448 }
449
450 query.append(ORDER_BY_CLAUSE);
451
452 String[] orderByFields = orderByComparator.getOrderByFields();
453
454 for (int i = 0; i < orderByFields.length; i++) {
455 query.append(_ORDER_BY_ENTITY_ALIAS);
456 query.append(orderByFields[i]);
457
458 if ((i + 1) < orderByFields.length) {
459 if (orderByComparator.isAscending() ^ previous) {
460 query.append(ORDER_BY_ASC_HAS_NEXT);
461 }
462 else {
463 query.append(ORDER_BY_DESC_HAS_NEXT);
464 }
465 }
466 else {
467 if (orderByComparator.isAscending() ^ previous) {
468 query.append(ORDER_BY_ASC);
469 }
470 else {
471 query.append(ORDER_BY_DESC);
472 }
473 }
474 }
475 }
476 else {
477 query.append(ExpandoValueModelImpl.ORDER_BY_JPQL);
478 }
479
480 String sql = query.toString();
481
482 Query q = session.createQuery(sql);
483
484 q.setFirstResult(0);
485 q.setMaxResults(2);
486
487 QueryPos qPos = QueryPos.getInstance(q);
488
489 qPos.add(tableId);
490
491 if (orderByComparator != null) {
492 Object[] values = orderByComparator.getOrderByConditionValues(expandoValue);
493
494 for (Object value : values) {
495 qPos.add(value);
496 }
497 }
498
499 List<ExpandoValue> list = q.list();
500
501 if (list.size() == 2) {
502 return list.get(1);
503 }
504 else {
505 return null;
506 }
507 }
508
509
515 @Override
516 public void removeByTableId(long tableId) throws SystemException {
517 for (ExpandoValue expandoValue : findByTableId(tableId,
518 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
519 remove(expandoValue);
520 }
521 }
522
523
530 @Override
531 public int countByTableId(long tableId) throws SystemException {
532 FinderPath finderPath = FINDER_PATH_COUNT_BY_TABLEID;
533
534 Object[] finderArgs = new Object[] { tableId };
535
536 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
537 this);
538
539 if (count == null) {
540 StringBundler query = new StringBundler(2);
541
542 query.append(_SQL_COUNT_EXPANDOVALUE_WHERE);
543
544 query.append(_FINDER_COLUMN_TABLEID_TABLEID_2);
545
546 String sql = query.toString();
547
548 Session session = null;
549
550 try {
551 session = openSession();
552
553 Query q = session.createQuery(sql);
554
555 QueryPos qPos = QueryPos.getInstance(q);
556
557 qPos.add(tableId);
558
559 count = (Long)q.uniqueResult();
560
561 FinderCacheUtil.putResult(finderPath, finderArgs, count);
562 }
563 catch (Exception e) {
564 FinderCacheUtil.removeResult(finderPath, finderArgs);
565
566 throw processException(e);
567 }
568 finally {
569 closeSession(session);
570 }
571 }
572
573 return count.intValue();
574 }
575
576 private static final String _FINDER_COLUMN_TABLEID_TABLEID_2 = "expandoValue.tableId = ?";
577 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_COLUMNID = new FinderPath(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
578 ExpandoValueModelImpl.FINDER_CACHE_ENABLED, ExpandoValueImpl.class,
579 FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByColumnId",
580 new String[] {
581 Long.class.getName(),
582
583 Integer.class.getName(), Integer.class.getName(),
584 OrderByComparator.class.getName()
585 });
586 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_COLUMNID =
587 new FinderPath(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
588 ExpandoValueModelImpl.FINDER_CACHE_ENABLED, ExpandoValueImpl.class,
589 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByColumnId",
590 new String[] { Long.class.getName() },
591 ExpandoValueModelImpl.COLUMNID_COLUMN_BITMASK |
592 ExpandoValueModelImpl.TABLEID_COLUMN_BITMASK |
593 ExpandoValueModelImpl.ROWID_COLUMN_BITMASK);
594 public static final FinderPath FINDER_PATH_COUNT_BY_COLUMNID = new FinderPath(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
595 ExpandoValueModelImpl.FINDER_CACHE_ENABLED, Long.class,
596 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByColumnId",
597 new String[] { Long.class.getName() });
598
599
606 @Override
607 public List<ExpandoValue> findByColumnId(long columnId)
608 throws SystemException {
609 return findByColumnId(columnId, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
610 null);
611 }
612
613
626 @Override
627 public List<ExpandoValue> findByColumnId(long columnId, int start, int end)
628 throws SystemException {
629 return findByColumnId(columnId, start, end, null);
630 }
631
632
646 @Override
647 public List<ExpandoValue> findByColumnId(long columnId, int start, int end,
648 OrderByComparator orderByComparator) throws SystemException {
649 boolean pagination = true;
650 FinderPath finderPath = null;
651 Object[] finderArgs = null;
652
653 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
654 (orderByComparator == null)) {
655 pagination = false;
656 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_COLUMNID;
657 finderArgs = new Object[] { columnId };
658 }
659 else {
660 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_COLUMNID;
661 finderArgs = new Object[] { columnId, start, end, orderByComparator };
662 }
663
664 List<ExpandoValue> list = (List<ExpandoValue>)FinderCacheUtil.getResult(finderPath,
665 finderArgs, this);
666
667 if ((list != null) && !list.isEmpty()) {
668 for (ExpandoValue expandoValue : list) {
669 if ((columnId != expandoValue.getColumnId())) {
670 list = null;
671
672 break;
673 }
674 }
675 }
676
677 if (list == null) {
678 StringBundler query = null;
679
680 if (orderByComparator != null) {
681 query = new StringBundler(3 +
682 (orderByComparator.getOrderByFields().length * 3));
683 }
684 else {
685 query = new StringBundler(3);
686 }
687
688 query.append(_SQL_SELECT_EXPANDOVALUE_WHERE);
689
690 query.append(_FINDER_COLUMN_COLUMNID_COLUMNID_2);
691
692 if (orderByComparator != null) {
693 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
694 orderByComparator);
695 }
696 else
697 if (pagination) {
698 query.append(ExpandoValueModelImpl.ORDER_BY_JPQL);
699 }
700
701 String sql = query.toString();
702
703 Session session = null;
704
705 try {
706 session = openSession();
707
708 Query q = session.createQuery(sql);
709
710 QueryPos qPos = QueryPos.getInstance(q);
711
712 qPos.add(columnId);
713
714 if (!pagination) {
715 list = (List<ExpandoValue>)QueryUtil.list(q, getDialect(),
716 start, end, false);
717
718 Collections.sort(list);
719
720 list = new UnmodifiableList<ExpandoValue>(list);
721 }
722 else {
723 list = (List<ExpandoValue>)QueryUtil.list(q, getDialect(),
724 start, end);
725 }
726
727 cacheResult(list);
728
729 FinderCacheUtil.putResult(finderPath, finderArgs, list);
730 }
731 catch (Exception e) {
732 FinderCacheUtil.removeResult(finderPath, finderArgs);
733
734 throw processException(e);
735 }
736 finally {
737 closeSession(session);
738 }
739 }
740
741 return list;
742 }
743
744
753 @Override
754 public ExpandoValue findByColumnId_First(long columnId,
755 OrderByComparator orderByComparator)
756 throws NoSuchValueException, SystemException {
757 ExpandoValue expandoValue = fetchByColumnId_First(columnId,
758 orderByComparator);
759
760 if (expandoValue != null) {
761 return expandoValue;
762 }
763
764 StringBundler msg = new StringBundler(4);
765
766 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
767
768 msg.append("columnId=");
769 msg.append(columnId);
770
771 msg.append(StringPool.CLOSE_CURLY_BRACE);
772
773 throw new NoSuchValueException(msg.toString());
774 }
775
776
784 @Override
785 public ExpandoValue fetchByColumnId_First(long columnId,
786 OrderByComparator orderByComparator) throws SystemException {
787 List<ExpandoValue> list = findByColumnId(columnId, 0, 1,
788 orderByComparator);
789
790 if (!list.isEmpty()) {
791 return list.get(0);
792 }
793
794 return null;
795 }
796
797
806 @Override
807 public ExpandoValue findByColumnId_Last(long columnId,
808 OrderByComparator orderByComparator)
809 throws NoSuchValueException, SystemException {
810 ExpandoValue expandoValue = fetchByColumnId_Last(columnId,
811 orderByComparator);
812
813 if (expandoValue != null) {
814 return expandoValue;
815 }
816
817 StringBundler msg = new StringBundler(4);
818
819 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
820
821 msg.append("columnId=");
822 msg.append(columnId);
823
824 msg.append(StringPool.CLOSE_CURLY_BRACE);
825
826 throw new NoSuchValueException(msg.toString());
827 }
828
829
837 @Override
838 public ExpandoValue fetchByColumnId_Last(long columnId,
839 OrderByComparator orderByComparator) throws SystemException {
840 int count = countByColumnId(columnId);
841
842 if (count == 0) {
843 return null;
844 }
845
846 List<ExpandoValue> list = findByColumnId(columnId, count - 1, count,
847 orderByComparator);
848
849 if (!list.isEmpty()) {
850 return list.get(0);
851 }
852
853 return null;
854 }
855
856
866 @Override
867 public ExpandoValue[] findByColumnId_PrevAndNext(long valueId,
868 long columnId, OrderByComparator orderByComparator)
869 throws NoSuchValueException, SystemException {
870 ExpandoValue expandoValue = findByPrimaryKey(valueId);
871
872 Session session = null;
873
874 try {
875 session = openSession();
876
877 ExpandoValue[] array = new ExpandoValueImpl[3];
878
879 array[0] = getByColumnId_PrevAndNext(session, expandoValue,
880 columnId, orderByComparator, true);
881
882 array[1] = expandoValue;
883
884 array[2] = getByColumnId_PrevAndNext(session, expandoValue,
885 columnId, orderByComparator, false);
886
887 return array;
888 }
889 catch (Exception e) {
890 throw processException(e);
891 }
892 finally {
893 closeSession(session);
894 }
895 }
896
897 protected ExpandoValue getByColumnId_PrevAndNext(Session session,
898 ExpandoValue expandoValue, long columnId,
899 OrderByComparator orderByComparator, boolean previous) {
900 StringBundler query = null;
901
902 if (orderByComparator != null) {
903 query = new StringBundler(6 +
904 (orderByComparator.getOrderByFields().length * 6));
905 }
906 else {
907 query = new StringBundler(3);
908 }
909
910 query.append(_SQL_SELECT_EXPANDOVALUE_WHERE);
911
912 query.append(_FINDER_COLUMN_COLUMNID_COLUMNID_2);
913
914 if (orderByComparator != null) {
915 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
916
917 if (orderByConditionFields.length > 0) {
918 query.append(WHERE_AND);
919 }
920
921 for (int i = 0; i < orderByConditionFields.length; i++) {
922 query.append(_ORDER_BY_ENTITY_ALIAS);
923 query.append(orderByConditionFields[i]);
924
925 if ((i + 1) < orderByConditionFields.length) {
926 if (orderByComparator.isAscending() ^ previous) {
927 query.append(WHERE_GREATER_THAN_HAS_NEXT);
928 }
929 else {
930 query.append(WHERE_LESSER_THAN_HAS_NEXT);
931 }
932 }
933 else {
934 if (orderByComparator.isAscending() ^ previous) {
935 query.append(WHERE_GREATER_THAN);
936 }
937 else {
938 query.append(WHERE_LESSER_THAN);
939 }
940 }
941 }
942
943 query.append(ORDER_BY_CLAUSE);
944
945 String[] orderByFields = orderByComparator.getOrderByFields();
946
947 for (int i = 0; i < orderByFields.length; i++) {
948 query.append(_ORDER_BY_ENTITY_ALIAS);
949 query.append(orderByFields[i]);
950
951 if ((i + 1) < orderByFields.length) {
952 if (orderByComparator.isAscending() ^ previous) {
953 query.append(ORDER_BY_ASC_HAS_NEXT);
954 }
955 else {
956 query.append(ORDER_BY_DESC_HAS_NEXT);
957 }
958 }
959 else {
960 if (orderByComparator.isAscending() ^ previous) {
961 query.append(ORDER_BY_ASC);
962 }
963 else {
964 query.append(ORDER_BY_DESC);
965 }
966 }
967 }
968 }
969 else {
970 query.append(ExpandoValueModelImpl.ORDER_BY_JPQL);
971 }
972
973 String sql = query.toString();
974
975 Query q = session.createQuery(sql);
976
977 q.setFirstResult(0);
978 q.setMaxResults(2);
979
980 QueryPos qPos = QueryPos.getInstance(q);
981
982 qPos.add(columnId);
983
984 if (orderByComparator != null) {
985 Object[] values = orderByComparator.getOrderByConditionValues(expandoValue);
986
987 for (Object value : values) {
988 qPos.add(value);
989 }
990 }
991
992 List<ExpandoValue> list = q.list();
993
994 if (list.size() == 2) {
995 return list.get(1);
996 }
997 else {
998 return null;
999 }
1000 }
1001
1002
1008 @Override
1009 public void removeByColumnId(long columnId) throws SystemException {
1010 for (ExpandoValue expandoValue : findByColumnId(columnId,
1011 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
1012 remove(expandoValue);
1013 }
1014 }
1015
1016
1023 @Override
1024 public int countByColumnId(long columnId) throws SystemException {
1025 FinderPath finderPath = FINDER_PATH_COUNT_BY_COLUMNID;
1026
1027 Object[] finderArgs = new Object[] { columnId };
1028
1029 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
1030 this);
1031
1032 if (count == null) {
1033 StringBundler query = new StringBundler(2);
1034
1035 query.append(_SQL_COUNT_EXPANDOVALUE_WHERE);
1036
1037 query.append(_FINDER_COLUMN_COLUMNID_COLUMNID_2);
1038
1039 String sql = query.toString();
1040
1041 Session session = null;
1042
1043 try {
1044 session = openSession();
1045
1046 Query q = session.createQuery(sql);
1047
1048 QueryPos qPos = QueryPos.getInstance(q);
1049
1050 qPos.add(columnId);
1051
1052 count = (Long)q.uniqueResult();
1053
1054 FinderCacheUtil.putResult(finderPath, finderArgs, count);
1055 }
1056 catch (Exception e) {
1057 FinderCacheUtil.removeResult(finderPath, finderArgs);
1058
1059 throw processException(e);
1060 }
1061 finally {
1062 closeSession(session);
1063 }
1064 }
1065
1066 return count.intValue();
1067 }
1068
1069 private static final String _FINDER_COLUMN_COLUMNID_COLUMNID_2 = "expandoValue.columnId = ?";
1070 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_ROWID = new FinderPath(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
1071 ExpandoValueModelImpl.FINDER_CACHE_ENABLED, ExpandoValueImpl.class,
1072 FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByRowId",
1073 new String[] {
1074 Long.class.getName(),
1075
1076 Integer.class.getName(), Integer.class.getName(),
1077 OrderByComparator.class.getName()
1078 });
1079 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_ROWID = new FinderPath(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
1080 ExpandoValueModelImpl.FINDER_CACHE_ENABLED, ExpandoValueImpl.class,
1081 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByRowId",
1082 new String[] { Long.class.getName() },
1083 ExpandoValueModelImpl.ROWID_COLUMN_BITMASK |
1084 ExpandoValueModelImpl.TABLEID_COLUMN_BITMASK |
1085 ExpandoValueModelImpl.COLUMNID_COLUMN_BITMASK);
1086 public static final FinderPath FINDER_PATH_COUNT_BY_ROWID = new FinderPath(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
1087 ExpandoValueModelImpl.FINDER_CACHE_ENABLED, Long.class,
1088 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByRowId",
1089 new String[] { Long.class.getName() });
1090
1091
1098 @Override
1099 public List<ExpandoValue> findByRowId(long rowId) throws SystemException {
1100 return findByRowId(rowId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1101 }
1102
1103
1116 @Override
1117 public List<ExpandoValue> findByRowId(long rowId, int start, int end)
1118 throws SystemException {
1119 return findByRowId(rowId, start, end, null);
1120 }
1121
1122
1136 @Override
1137 public List<ExpandoValue> findByRowId(long rowId, int start, int end,
1138 OrderByComparator orderByComparator) throws SystemException {
1139 boolean pagination = true;
1140 FinderPath finderPath = null;
1141 Object[] finderArgs = null;
1142
1143 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
1144 (orderByComparator == null)) {
1145 pagination = false;
1146 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_ROWID;
1147 finderArgs = new Object[] { rowId };
1148 }
1149 else {
1150 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_ROWID;
1151 finderArgs = new Object[] { rowId, start, end, orderByComparator };
1152 }
1153
1154 List<ExpandoValue> list = (List<ExpandoValue>)FinderCacheUtil.getResult(finderPath,
1155 finderArgs, this);
1156
1157 if ((list != null) && !list.isEmpty()) {
1158 for (ExpandoValue expandoValue : list) {
1159 if ((rowId != expandoValue.getRowId())) {
1160 list = null;
1161
1162 break;
1163 }
1164 }
1165 }
1166
1167 if (list == null) {
1168 StringBundler query = null;
1169
1170 if (orderByComparator != null) {
1171 query = new StringBundler(3 +
1172 (orderByComparator.getOrderByFields().length * 3));
1173 }
1174 else {
1175 query = new StringBundler(3);
1176 }
1177
1178 query.append(_SQL_SELECT_EXPANDOVALUE_WHERE);
1179
1180 query.append(_FINDER_COLUMN_ROWID_ROWID_2);
1181
1182 if (orderByComparator != null) {
1183 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1184 orderByComparator);
1185 }
1186 else
1187 if (pagination) {
1188 query.append(ExpandoValueModelImpl.ORDER_BY_JPQL);
1189 }
1190
1191 String sql = query.toString();
1192
1193 Session session = null;
1194
1195 try {
1196 session = openSession();
1197
1198 Query q = session.createQuery(sql);
1199
1200 QueryPos qPos = QueryPos.getInstance(q);
1201
1202 qPos.add(rowId);
1203
1204 if (!pagination) {
1205 list = (List<ExpandoValue>)QueryUtil.list(q, getDialect(),
1206 start, end, false);
1207
1208 Collections.sort(list);
1209
1210 list = new UnmodifiableList<ExpandoValue>(list);
1211 }
1212 else {
1213 list = (List<ExpandoValue>)QueryUtil.list(q, getDialect(),
1214 start, end);
1215 }
1216
1217 cacheResult(list);
1218
1219 FinderCacheUtil.putResult(finderPath, finderArgs, list);
1220 }
1221 catch (Exception e) {
1222 FinderCacheUtil.removeResult(finderPath, finderArgs);
1223
1224 throw processException(e);
1225 }
1226 finally {
1227 closeSession(session);
1228 }
1229 }
1230
1231 return list;
1232 }
1233
1234
1243 @Override
1244 public ExpandoValue findByRowId_First(long rowId,
1245 OrderByComparator orderByComparator)
1246 throws NoSuchValueException, SystemException {
1247 ExpandoValue expandoValue = fetchByRowId_First(rowId, orderByComparator);
1248
1249 if (expandoValue != null) {
1250 return expandoValue;
1251 }
1252
1253 StringBundler msg = new StringBundler(4);
1254
1255 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1256
1257 msg.append("rowId=");
1258 msg.append(rowId);
1259
1260 msg.append(StringPool.CLOSE_CURLY_BRACE);
1261
1262 throw new NoSuchValueException(msg.toString());
1263 }
1264
1265
1273 @Override
1274 public ExpandoValue fetchByRowId_First(long rowId,
1275 OrderByComparator orderByComparator) throws SystemException {
1276 List<ExpandoValue> list = findByRowId(rowId, 0, 1, orderByComparator);
1277
1278 if (!list.isEmpty()) {
1279 return list.get(0);
1280 }
1281
1282 return null;
1283 }
1284
1285
1294 @Override
1295 public ExpandoValue findByRowId_Last(long rowId,
1296 OrderByComparator orderByComparator)
1297 throws NoSuchValueException, SystemException {
1298 ExpandoValue expandoValue = fetchByRowId_Last(rowId, orderByComparator);
1299
1300 if (expandoValue != null) {
1301 return expandoValue;
1302 }
1303
1304 StringBundler msg = new StringBundler(4);
1305
1306 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1307
1308 msg.append("rowId=");
1309 msg.append(rowId);
1310
1311 msg.append(StringPool.CLOSE_CURLY_BRACE);
1312
1313 throw new NoSuchValueException(msg.toString());
1314 }
1315
1316
1324 @Override
1325 public ExpandoValue fetchByRowId_Last(long rowId,
1326 OrderByComparator orderByComparator) throws SystemException {
1327 int count = countByRowId(rowId);
1328
1329 if (count == 0) {
1330 return null;
1331 }
1332
1333 List<ExpandoValue> list = findByRowId(rowId, count - 1, count,
1334 orderByComparator);
1335
1336 if (!list.isEmpty()) {
1337 return list.get(0);
1338 }
1339
1340 return null;
1341 }
1342
1343
1353 @Override
1354 public ExpandoValue[] findByRowId_PrevAndNext(long valueId, long rowId,
1355 OrderByComparator orderByComparator)
1356 throws NoSuchValueException, SystemException {
1357 ExpandoValue expandoValue = findByPrimaryKey(valueId);
1358
1359 Session session = null;
1360
1361 try {
1362 session = openSession();
1363
1364 ExpandoValue[] array = new ExpandoValueImpl[3];
1365
1366 array[0] = getByRowId_PrevAndNext(session, expandoValue, rowId,
1367 orderByComparator, true);
1368
1369 array[1] = expandoValue;
1370
1371 array[2] = getByRowId_PrevAndNext(session, expandoValue, rowId,
1372 orderByComparator, false);
1373
1374 return array;
1375 }
1376 catch (Exception e) {
1377 throw processException(e);
1378 }
1379 finally {
1380 closeSession(session);
1381 }
1382 }
1383
1384 protected ExpandoValue getByRowId_PrevAndNext(Session session,
1385 ExpandoValue expandoValue, long rowId,
1386 OrderByComparator orderByComparator, boolean previous) {
1387 StringBundler query = null;
1388
1389 if (orderByComparator != null) {
1390 query = new StringBundler(6 +
1391 (orderByComparator.getOrderByFields().length * 6));
1392 }
1393 else {
1394 query = new StringBundler(3);
1395 }
1396
1397 query.append(_SQL_SELECT_EXPANDOVALUE_WHERE);
1398
1399 query.append(_FINDER_COLUMN_ROWID_ROWID_2);
1400
1401 if (orderByComparator != null) {
1402 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
1403
1404 if (orderByConditionFields.length > 0) {
1405 query.append(WHERE_AND);
1406 }
1407
1408 for (int i = 0; i < orderByConditionFields.length; i++) {
1409 query.append(_ORDER_BY_ENTITY_ALIAS);
1410 query.append(orderByConditionFields[i]);
1411
1412 if ((i + 1) < orderByConditionFields.length) {
1413 if (orderByComparator.isAscending() ^ previous) {
1414 query.append(WHERE_GREATER_THAN_HAS_NEXT);
1415 }
1416 else {
1417 query.append(WHERE_LESSER_THAN_HAS_NEXT);
1418 }
1419 }
1420 else {
1421 if (orderByComparator.isAscending() ^ previous) {
1422 query.append(WHERE_GREATER_THAN);
1423 }
1424 else {
1425 query.append(WHERE_LESSER_THAN);
1426 }
1427 }
1428 }
1429
1430 query.append(ORDER_BY_CLAUSE);
1431
1432 String[] orderByFields = orderByComparator.getOrderByFields();
1433
1434 for (int i = 0; i < orderByFields.length; i++) {
1435 query.append(_ORDER_BY_ENTITY_ALIAS);
1436 query.append(orderByFields[i]);
1437
1438 if ((i + 1) < orderByFields.length) {
1439 if (orderByComparator.isAscending() ^ previous) {
1440 query.append(ORDER_BY_ASC_HAS_NEXT);
1441 }
1442 else {
1443 query.append(ORDER_BY_DESC_HAS_NEXT);
1444 }
1445 }
1446 else {
1447 if (orderByComparator.isAscending() ^ previous) {
1448 query.append(ORDER_BY_ASC);
1449 }
1450 else {
1451 query.append(ORDER_BY_DESC);
1452 }
1453 }
1454 }
1455 }
1456 else {
1457 query.append(ExpandoValueModelImpl.ORDER_BY_JPQL);
1458 }
1459
1460 String sql = query.toString();
1461
1462 Query q = session.createQuery(sql);
1463
1464 q.setFirstResult(0);
1465 q.setMaxResults(2);
1466
1467 QueryPos qPos = QueryPos.getInstance(q);
1468
1469 qPos.add(rowId);
1470
1471 if (orderByComparator != null) {
1472 Object[] values = orderByComparator.getOrderByConditionValues(expandoValue);
1473
1474 for (Object value : values) {
1475 qPos.add(value);
1476 }
1477 }
1478
1479 List<ExpandoValue> list = q.list();
1480
1481 if (list.size() == 2) {
1482 return list.get(1);
1483 }
1484 else {
1485 return null;
1486 }
1487 }
1488
1489
1495 @Override
1496 public void removeByRowId(long rowId) throws SystemException {
1497 for (ExpandoValue expandoValue : findByRowId(rowId, QueryUtil.ALL_POS,
1498 QueryUtil.ALL_POS, null)) {
1499 remove(expandoValue);
1500 }
1501 }
1502
1503
1510 @Override
1511 public int countByRowId(long rowId) throws SystemException {
1512 FinderPath finderPath = FINDER_PATH_COUNT_BY_ROWID;
1513
1514 Object[] finderArgs = new Object[] { rowId };
1515
1516 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
1517 this);
1518
1519 if (count == null) {
1520 StringBundler query = new StringBundler(2);
1521
1522 query.append(_SQL_COUNT_EXPANDOVALUE_WHERE);
1523
1524 query.append(_FINDER_COLUMN_ROWID_ROWID_2);
1525
1526 String sql = query.toString();
1527
1528 Session session = null;
1529
1530 try {
1531 session = openSession();
1532
1533 Query q = session.createQuery(sql);
1534
1535 QueryPos qPos = QueryPos.getInstance(q);
1536
1537 qPos.add(rowId);
1538
1539 count = (Long)q.uniqueResult();
1540
1541 FinderCacheUtil.putResult(finderPath, finderArgs, count);
1542 }
1543 catch (Exception e) {
1544 FinderCacheUtil.removeResult(finderPath, finderArgs);
1545
1546 throw processException(e);
1547 }
1548 finally {
1549 closeSession(session);
1550 }
1551 }
1552
1553 return count.intValue();
1554 }
1555
1556 private static final String _FINDER_COLUMN_ROWID_ROWID_2 = "expandoValue.rowId = ?";
1557 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_T_C = new FinderPath(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
1558 ExpandoValueModelImpl.FINDER_CACHE_ENABLED, ExpandoValueImpl.class,
1559 FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByT_C",
1560 new String[] {
1561 Long.class.getName(), Long.class.getName(),
1562
1563 Integer.class.getName(), Integer.class.getName(),
1564 OrderByComparator.class.getName()
1565 });
1566 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_T_C = new FinderPath(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
1567 ExpandoValueModelImpl.FINDER_CACHE_ENABLED, ExpandoValueImpl.class,
1568 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByT_C",
1569 new String[] { Long.class.getName(), Long.class.getName() },
1570 ExpandoValueModelImpl.TABLEID_COLUMN_BITMASK |
1571 ExpandoValueModelImpl.COLUMNID_COLUMN_BITMASK |
1572 ExpandoValueModelImpl.ROWID_COLUMN_BITMASK);
1573 public static final FinderPath FINDER_PATH_COUNT_BY_T_C = new FinderPath(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
1574 ExpandoValueModelImpl.FINDER_CACHE_ENABLED, Long.class,
1575 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByT_C",
1576 new String[] { Long.class.getName(), Long.class.getName() });
1577
1578
1586 @Override
1587 public List<ExpandoValue> findByT_C(long tableId, long columnId)
1588 throws SystemException {
1589 return findByT_C(tableId, columnId, QueryUtil.ALL_POS,
1590 QueryUtil.ALL_POS, null);
1591 }
1592
1593
1607 @Override
1608 public List<ExpandoValue> findByT_C(long tableId, long columnId, int start,
1609 int end) throws SystemException {
1610 return findByT_C(tableId, columnId, start, end, null);
1611 }
1612
1613
1628 @Override
1629 public List<ExpandoValue> findByT_C(long tableId, long columnId, int start,
1630 int end, OrderByComparator orderByComparator) throws SystemException {
1631 boolean pagination = true;
1632 FinderPath finderPath = null;
1633 Object[] finderArgs = null;
1634
1635 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
1636 (orderByComparator == null)) {
1637 pagination = false;
1638 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_T_C;
1639 finderArgs = new Object[] { tableId, columnId };
1640 }
1641 else {
1642 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_T_C;
1643 finderArgs = new Object[] {
1644 tableId, columnId,
1645
1646 start, end, orderByComparator
1647 };
1648 }
1649
1650 List<ExpandoValue> list = (List<ExpandoValue>)FinderCacheUtil.getResult(finderPath,
1651 finderArgs, this);
1652
1653 if ((list != null) && !list.isEmpty()) {
1654 for (ExpandoValue expandoValue : list) {
1655 if ((tableId != expandoValue.getTableId()) ||
1656 (columnId != expandoValue.getColumnId())) {
1657 list = null;
1658
1659 break;
1660 }
1661 }
1662 }
1663
1664 if (list == null) {
1665 StringBundler query = null;
1666
1667 if (orderByComparator != null) {
1668 query = new StringBundler(4 +
1669 (orderByComparator.getOrderByFields().length * 3));
1670 }
1671 else {
1672 query = new StringBundler(4);
1673 }
1674
1675 query.append(_SQL_SELECT_EXPANDOVALUE_WHERE);
1676
1677 query.append(_FINDER_COLUMN_T_C_TABLEID_2);
1678
1679 query.append(_FINDER_COLUMN_T_C_COLUMNID_2);
1680
1681 if (orderByComparator != null) {
1682 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1683 orderByComparator);
1684 }
1685 else
1686 if (pagination) {
1687 query.append(ExpandoValueModelImpl.ORDER_BY_JPQL);
1688 }
1689
1690 String sql = query.toString();
1691
1692 Session session = null;
1693
1694 try {
1695 session = openSession();
1696
1697 Query q = session.createQuery(sql);
1698
1699 QueryPos qPos = QueryPos.getInstance(q);
1700
1701 qPos.add(tableId);
1702
1703 qPos.add(columnId);
1704
1705 if (!pagination) {
1706 list = (List<ExpandoValue>)QueryUtil.list(q, getDialect(),
1707 start, end, false);
1708
1709 Collections.sort(list);
1710
1711 list = new UnmodifiableList<ExpandoValue>(list);
1712 }
1713 else {
1714 list = (List<ExpandoValue>)QueryUtil.list(q, getDialect(),
1715 start, end);
1716 }
1717
1718 cacheResult(list);
1719
1720 FinderCacheUtil.putResult(finderPath, finderArgs, list);
1721 }
1722 catch (Exception e) {
1723 FinderCacheUtil.removeResult(finderPath, finderArgs);
1724
1725 throw processException(e);
1726 }
1727 finally {
1728 closeSession(session);
1729 }
1730 }
1731
1732 return list;
1733 }
1734
1735
1745 @Override
1746 public ExpandoValue findByT_C_First(long tableId, long columnId,
1747 OrderByComparator orderByComparator)
1748 throws NoSuchValueException, SystemException {
1749 ExpandoValue expandoValue = fetchByT_C_First(tableId, columnId,
1750 orderByComparator);
1751
1752 if (expandoValue != null) {
1753 return expandoValue;
1754 }
1755
1756 StringBundler msg = new StringBundler(6);
1757
1758 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1759
1760 msg.append("tableId=");
1761 msg.append(tableId);
1762
1763 msg.append(", columnId=");
1764 msg.append(columnId);
1765
1766 msg.append(StringPool.CLOSE_CURLY_BRACE);
1767
1768 throw new NoSuchValueException(msg.toString());
1769 }
1770
1771
1780 @Override
1781 public ExpandoValue fetchByT_C_First(long tableId, long columnId,
1782 OrderByComparator orderByComparator) throws SystemException {
1783 List<ExpandoValue> list = findByT_C(tableId, columnId, 0, 1,
1784 orderByComparator);
1785
1786 if (!list.isEmpty()) {
1787 return list.get(0);
1788 }
1789
1790 return null;
1791 }
1792
1793
1803 @Override
1804 public ExpandoValue findByT_C_Last(long tableId, long columnId,
1805 OrderByComparator orderByComparator)
1806 throws NoSuchValueException, SystemException {
1807 ExpandoValue expandoValue = fetchByT_C_Last(tableId, columnId,
1808 orderByComparator);
1809
1810 if (expandoValue != null) {
1811 return expandoValue;
1812 }
1813
1814 StringBundler msg = new StringBundler(6);
1815
1816 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1817
1818 msg.append("tableId=");
1819 msg.append(tableId);
1820
1821 msg.append(", columnId=");
1822 msg.append(columnId);
1823
1824 msg.append(StringPool.CLOSE_CURLY_BRACE);
1825
1826 throw new NoSuchValueException(msg.toString());
1827 }
1828
1829
1838 @Override
1839 public ExpandoValue fetchByT_C_Last(long tableId, long columnId,
1840 OrderByComparator orderByComparator) throws SystemException {
1841 int count = countByT_C(tableId, columnId);
1842
1843 if (count == 0) {
1844 return null;
1845 }
1846
1847 List<ExpandoValue> list = findByT_C(tableId, columnId, count - 1,
1848 count, orderByComparator);
1849
1850 if (!list.isEmpty()) {
1851 return list.get(0);
1852 }
1853
1854 return null;
1855 }
1856
1857
1868 @Override
1869 public ExpandoValue[] findByT_C_PrevAndNext(long valueId, long tableId,
1870 long columnId, OrderByComparator orderByComparator)
1871 throws NoSuchValueException, SystemException {
1872 ExpandoValue expandoValue = findByPrimaryKey(valueId);
1873
1874 Session session = null;
1875
1876 try {
1877 session = openSession();
1878
1879 ExpandoValue[] array = new ExpandoValueImpl[3];
1880
1881 array[0] = getByT_C_PrevAndNext(session, expandoValue, tableId,
1882 columnId, orderByComparator, true);
1883
1884 array[1] = expandoValue;
1885
1886 array[2] = getByT_C_PrevAndNext(session, expandoValue, tableId,
1887 columnId, orderByComparator, false);
1888
1889 return array;
1890 }
1891 catch (Exception e) {
1892 throw processException(e);
1893 }
1894 finally {
1895 closeSession(session);
1896 }
1897 }
1898
1899 protected ExpandoValue getByT_C_PrevAndNext(Session session,
1900 ExpandoValue expandoValue, long tableId, long columnId,
1901 OrderByComparator orderByComparator, boolean previous) {
1902 StringBundler query = null;
1903
1904 if (orderByComparator != null) {
1905 query = new StringBundler(6 +
1906 (orderByComparator.getOrderByFields().length * 6));
1907 }
1908 else {
1909 query = new StringBundler(3);
1910 }
1911
1912 query.append(_SQL_SELECT_EXPANDOVALUE_WHERE);
1913
1914 query.append(_FINDER_COLUMN_T_C_TABLEID_2);
1915
1916 query.append(_FINDER_COLUMN_T_C_COLUMNID_2);
1917
1918 if (orderByComparator != null) {
1919 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
1920
1921 if (orderByConditionFields.length > 0) {
1922 query.append(WHERE_AND);
1923 }
1924
1925 for (int i = 0; i < orderByConditionFields.length; i++) {
1926 query.append(_ORDER_BY_ENTITY_ALIAS);
1927 query.append(orderByConditionFields[i]);
1928
1929 if ((i + 1) < orderByConditionFields.length) {
1930 if (orderByComparator.isAscending() ^ previous) {
1931 query.append(WHERE_GREATER_THAN_HAS_NEXT);
1932 }
1933 else {
1934 query.append(WHERE_LESSER_THAN_HAS_NEXT);
1935 }
1936 }
1937 else {
1938 if (orderByComparator.isAscending() ^ previous) {
1939 query.append(WHERE_GREATER_THAN);
1940 }
1941 else {
1942 query.append(WHERE_LESSER_THAN);
1943 }
1944 }
1945 }
1946
1947 query.append(ORDER_BY_CLAUSE);
1948
1949 String[] orderByFields = orderByComparator.getOrderByFields();
1950
1951 for (int i = 0; i < orderByFields.length; i++) {
1952 query.append(_ORDER_BY_ENTITY_ALIAS);
1953 query.append(orderByFields[i]);
1954
1955 if ((i + 1) < orderByFields.length) {
1956 if (orderByComparator.isAscending() ^ previous) {
1957 query.append(ORDER_BY_ASC_HAS_NEXT);
1958 }
1959 else {
1960 query.append(ORDER_BY_DESC_HAS_NEXT);
1961 }
1962 }
1963 else {
1964 if (orderByComparator.isAscending() ^ previous) {
1965 query.append(ORDER_BY_ASC);
1966 }
1967 else {
1968 query.append(ORDER_BY_DESC);
1969 }
1970 }
1971 }
1972 }
1973 else {
1974 query.append(ExpandoValueModelImpl.ORDER_BY_JPQL);
1975 }
1976
1977 String sql = query.toString();
1978
1979 Query q = session.createQuery(sql);
1980
1981 q.setFirstResult(0);
1982 q.setMaxResults(2);
1983
1984 QueryPos qPos = QueryPos.getInstance(q);
1985
1986 qPos.add(tableId);
1987
1988 qPos.add(columnId);
1989
1990 if (orderByComparator != null) {
1991 Object[] values = orderByComparator.getOrderByConditionValues(expandoValue);
1992
1993 for (Object value : values) {
1994 qPos.add(value);
1995 }
1996 }
1997
1998 List<ExpandoValue> list = q.list();
1999
2000 if (list.size() == 2) {
2001 return list.get(1);
2002 }
2003 else {
2004 return null;
2005 }
2006 }
2007
2008
2015 @Override
2016 public void removeByT_C(long tableId, long columnId)
2017 throws SystemException {
2018 for (ExpandoValue expandoValue : findByT_C(tableId, columnId,
2019 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
2020 remove(expandoValue);
2021 }
2022 }
2023
2024
2032 @Override
2033 public int countByT_C(long tableId, long columnId)
2034 throws SystemException {
2035 FinderPath finderPath = FINDER_PATH_COUNT_BY_T_C;
2036
2037 Object[] finderArgs = new Object[] { tableId, columnId };
2038
2039 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
2040 this);
2041
2042 if (count == null) {
2043 StringBundler query = new StringBundler(3);
2044
2045 query.append(_SQL_COUNT_EXPANDOVALUE_WHERE);
2046
2047 query.append(_FINDER_COLUMN_T_C_TABLEID_2);
2048
2049 query.append(_FINDER_COLUMN_T_C_COLUMNID_2);
2050
2051 String sql = query.toString();
2052
2053 Session session = null;
2054
2055 try {
2056 session = openSession();
2057
2058 Query q = session.createQuery(sql);
2059
2060 QueryPos qPos = QueryPos.getInstance(q);
2061
2062 qPos.add(tableId);
2063
2064 qPos.add(columnId);
2065
2066 count = (Long)q.uniqueResult();
2067
2068 FinderCacheUtil.putResult(finderPath, finderArgs, count);
2069 }
2070 catch (Exception e) {
2071 FinderCacheUtil.removeResult(finderPath, finderArgs);
2072
2073 throw processException(e);
2074 }
2075 finally {
2076 closeSession(session);
2077 }
2078 }
2079
2080 return count.intValue();
2081 }
2082
2083 private static final String _FINDER_COLUMN_T_C_TABLEID_2 = "expandoValue.tableId = ? AND ";
2084 private static final String _FINDER_COLUMN_T_C_COLUMNID_2 = "expandoValue.columnId = ?";
2085 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_T_CPK = new FinderPath(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
2086 ExpandoValueModelImpl.FINDER_CACHE_ENABLED, ExpandoValueImpl.class,
2087 FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByT_CPK",
2088 new String[] {
2089 Long.class.getName(), Long.class.getName(),
2090
2091 Integer.class.getName(), Integer.class.getName(),
2092 OrderByComparator.class.getName()
2093 });
2094 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_T_CPK = new FinderPath(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
2095 ExpandoValueModelImpl.FINDER_CACHE_ENABLED, ExpandoValueImpl.class,
2096 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByT_CPK",
2097 new String[] { Long.class.getName(), Long.class.getName() },
2098 ExpandoValueModelImpl.TABLEID_COLUMN_BITMASK |
2099 ExpandoValueModelImpl.CLASSPK_COLUMN_BITMASK |
2100 ExpandoValueModelImpl.ROWID_COLUMN_BITMASK |
2101 ExpandoValueModelImpl.COLUMNID_COLUMN_BITMASK);
2102 public static final FinderPath FINDER_PATH_COUNT_BY_T_CPK = new FinderPath(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
2103 ExpandoValueModelImpl.FINDER_CACHE_ENABLED, Long.class,
2104 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByT_CPK",
2105 new String[] { Long.class.getName(), Long.class.getName() });
2106
2107
2115 @Override
2116 public List<ExpandoValue> findByT_CPK(long tableId, long classPK)
2117 throws SystemException {
2118 return findByT_CPK(tableId, classPK, QueryUtil.ALL_POS,
2119 QueryUtil.ALL_POS, null);
2120 }
2121
2122
2136 @Override
2137 public List<ExpandoValue> findByT_CPK(long tableId, long classPK,
2138 int start, int end) throws SystemException {
2139 return findByT_CPK(tableId, classPK, start, end, null);
2140 }
2141
2142
2157 @Override
2158 public List<ExpandoValue> findByT_CPK(long tableId, long classPK,
2159 int start, int end, OrderByComparator orderByComparator)
2160 throws SystemException {
2161 boolean pagination = true;
2162 FinderPath finderPath = null;
2163 Object[] finderArgs = null;
2164
2165 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
2166 (orderByComparator == null)) {
2167 pagination = false;
2168 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_T_CPK;
2169 finderArgs = new Object[] { tableId, classPK };
2170 }
2171 else {
2172 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_T_CPK;
2173 finderArgs = new Object[] {
2174 tableId, classPK,
2175
2176 start, end, orderByComparator
2177 };
2178 }
2179
2180 List<ExpandoValue> list = (List<ExpandoValue>)FinderCacheUtil.getResult(finderPath,
2181 finderArgs, this);
2182
2183 if ((list != null) && !list.isEmpty()) {
2184 for (ExpandoValue expandoValue : list) {
2185 if ((tableId != expandoValue.getTableId()) ||
2186 (classPK != expandoValue.getClassPK())) {
2187 list = null;
2188
2189 break;
2190 }
2191 }
2192 }
2193
2194 if (list == null) {
2195 StringBundler query = null;
2196
2197 if (orderByComparator != null) {
2198 query = new StringBundler(4 +
2199 (orderByComparator.getOrderByFields().length * 3));
2200 }
2201 else {
2202 query = new StringBundler(4);
2203 }
2204
2205 query.append(_SQL_SELECT_EXPANDOVALUE_WHERE);
2206
2207 query.append(_FINDER_COLUMN_T_CPK_TABLEID_2);
2208
2209 query.append(_FINDER_COLUMN_T_CPK_CLASSPK_2);
2210
2211 if (orderByComparator != null) {
2212 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2213 orderByComparator);
2214 }
2215 else
2216 if (pagination) {
2217 query.append(ExpandoValueModelImpl.ORDER_BY_JPQL);
2218 }
2219
2220 String sql = query.toString();
2221
2222 Session session = null;
2223
2224 try {
2225 session = openSession();
2226
2227 Query q = session.createQuery(sql);
2228
2229 QueryPos qPos = QueryPos.getInstance(q);
2230
2231 qPos.add(tableId);
2232
2233 qPos.add(classPK);
2234
2235 if (!pagination) {
2236 list = (List<ExpandoValue>)QueryUtil.list(q, getDialect(),
2237 start, end, false);
2238
2239 Collections.sort(list);
2240
2241 list = new UnmodifiableList<ExpandoValue>(list);
2242 }
2243 else {
2244 list = (List<ExpandoValue>)QueryUtil.list(q, getDialect(),
2245 start, end);
2246 }
2247
2248 cacheResult(list);
2249
2250 FinderCacheUtil.putResult(finderPath, finderArgs, list);
2251 }
2252 catch (Exception e) {
2253 FinderCacheUtil.removeResult(finderPath, finderArgs);
2254
2255 throw processException(e);
2256 }
2257 finally {
2258 closeSession(session);
2259 }
2260 }
2261
2262 return list;
2263 }
2264
2265
2275 @Override
2276 public ExpandoValue findByT_CPK_First(long tableId, long classPK,
2277 OrderByComparator orderByComparator)
2278 throws NoSuchValueException, SystemException {
2279 ExpandoValue expandoValue = fetchByT_CPK_First(tableId, classPK,
2280 orderByComparator);
2281
2282 if (expandoValue != null) {
2283 return expandoValue;
2284 }
2285
2286 StringBundler msg = new StringBundler(6);
2287
2288 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2289
2290 msg.append("tableId=");
2291 msg.append(tableId);
2292
2293 msg.append(", classPK=");
2294 msg.append(classPK);
2295
2296 msg.append(StringPool.CLOSE_CURLY_BRACE);
2297
2298 throw new NoSuchValueException(msg.toString());
2299 }
2300
2301
2310 @Override
2311 public ExpandoValue fetchByT_CPK_First(long tableId, long classPK,
2312 OrderByComparator orderByComparator) throws SystemException {
2313 List<ExpandoValue> list = findByT_CPK(tableId, classPK, 0, 1,
2314 orderByComparator);
2315
2316 if (!list.isEmpty()) {
2317 return list.get(0);
2318 }
2319
2320 return null;
2321 }
2322
2323
2333 @Override
2334 public ExpandoValue findByT_CPK_Last(long tableId, long classPK,
2335 OrderByComparator orderByComparator)
2336 throws NoSuchValueException, SystemException {
2337 ExpandoValue expandoValue = fetchByT_CPK_Last(tableId, classPK,
2338 orderByComparator);
2339
2340 if (expandoValue != null) {
2341 return expandoValue;
2342 }
2343
2344 StringBundler msg = new StringBundler(6);
2345
2346 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2347
2348 msg.append("tableId=");
2349 msg.append(tableId);
2350
2351 msg.append(", classPK=");
2352 msg.append(classPK);
2353
2354 msg.append(StringPool.CLOSE_CURLY_BRACE);
2355
2356 throw new NoSuchValueException(msg.toString());
2357 }
2358
2359
2368 @Override
2369 public ExpandoValue fetchByT_CPK_Last(long tableId, long classPK,
2370 OrderByComparator orderByComparator) throws SystemException {
2371 int count = countByT_CPK(tableId, classPK);
2372
2373 if (count == 0) {
2374 return null;
2375 }
2376
2377 List<ExpandoValue> list = findByT_CPK(tableId, classPK, count - 1,
2378 count, orderByComparator);
2379
2380 if (!list.isEmpty()) {
2381 return list.get(0);
2382 }
2383
2384 return null;
2385 }
2386
2387
2398 @Override
2399 public ExpandoValue[] findByT_CPK_PrevAndNext(long valueId, long tableId,
2400 long classPK, OrderByComparator orderByComparator)
2401 throws NoSuchValueException, SystemException {
2402 ExpandoValue expandoValue = findByPrimaryKey(valueId);
2403
2404 Session session = null;
2405
2406 try {
2407 session = openSession();
2408
2409 ExpandoValue[] array = new ExpandoValueImpl[3];
2410
2411 array[0] = getByT_CPK_PrevAndNext(session, expandoValue, tableId,
2412 classPK, orderByComparator, true);
2413
2414 array[1] = expandoValue;
2415
2416 array[2] = getByT_CPK_PrevAndNext(session, expandoValue, tableId,
2417 classPK, orderByComparator, false);
2418
2419 return array;
2420 }
2421 catch (Exception e) {
2422 throw processException(e);
2423 }
2424 finally {
2425 closeSession(session);
2426 }
2427 }
2428
2429 protected ExpandoValue getByT_CPK_PrevAndNext(Session session,
2430 ExpandoValue expandoValue, long tableId, long classPK,
2431 OrderByComparator orderByComparator, boolean previous) {
2432 StringBundler query = null;
2433
2434 if (orderByComparator != null) {
2435 query = new StringBundler(6 +
2436 (orderByComparator.getOrderByFields().length * 6));
2437 }
2438 else {
2439 query = new StringBundler(3);
2440 }
2441
2442 query.append(_SQL_SELECT_EXPANDOVALUE_WHERE);
2443
2444 query.append(_FINDER_COLUMN_T_CPK_TABLEID_2);
2445
2446 query.append(_FINDER_COLUMN_T_CPK_CLASSPK_2);
2447
2448 if (orderByComparator != null) {
2449 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
2450
2451 if (orderByConditionFields.length > 0) {
2452 query.append(WHERE_AND);
2453 }
2454
2455 for (int i = 0; i < orderByConditionFields.length; i++) {
2456 query.append(_ORDER_BY_ENTITY_ALIAS);
2457 query.append(orderByConditionFields[i]);
2458
2459 if ((i + 1) < orderByConditionFields.length) {
2460 if (orderByComparator.isAscending() ^ previous) {
2461 query.append(WHERE_GREATER_THAN_HAS_NEXT);
2462 }
2463 else {
2464 query.append(WHERE_LESSER_THAN_HAS_NEXT);
2465 }
2466 }
2467 else {
2468 if (orderByComparator.isAscending() ^ previous) {
2469 query.append(WHERE_GREATER_THAN);
2470 }
2471 else {
2472 query.append(WHERE_LESSER_THAN);
2473 }
2474 }
2475 }
2476
2477 query.append(ORDER_BY_CLAUSE);
2478
2479 String[] orderByFields = orderByComparator.getOrderByFields();
2480
2481 for (int i = 0; i < orderByFields.length; i++) {
2482 query.append(_ORDER_BY_ENTITY_ALIAS);
2483 query.append(orderByFields[i]);
2484
2485 if ((i + 1) < orderByFields.length) {
2486 if (orderByComparator.isAscending() ^ previous) {
2487 query.append(ORDER_BY_ASC_HAS_NEXT);
2488 }
2489 else {
2490 query.append(ORDER_BY_DESC_HAS_NEXT);
2491 }
2492 }
2493 else {
2494 if (orderByComparator.isAscending() ^ previous) {
2495 query.append(ORDER_BY_ASC);
2496 }
2497 else {
2498 query.append(ORDER_BY_DESC);
2499 }
2500 }
2501 }
2502 }
2503 else {
2504 query.append(ExpandoValueModelImpl.ORDER_BY_JPQL);
2505 }
2506
2507 String sql = query.toString();
2508
2509 Query q = session.createQuery(sql);
2510
2511 q.setFirstResult(0);
2512 q.setMaxResults(2);
2513
2514 QueryPos qPos = QueryPos.getInstance(q);
2515
2516 qPos.add(tableId);
2517
2518 qPos.add(classPK);
2519
2520 if (orderByComparator != null) {
2521 Object[] values = orderByComparator.getOrderByConditionValues(expandoValue);
2522
2523 for (Object value : values) {
2524 qPos.add(value);
2525 }
2526 }
2527
2528 List<ExpandoValue> list = q.list();
2529
2530 if (list.size() == 2) {
2531 return list.get(1);
2532 }
2533 else {
2534 return null;
2535 }
2536 }
2537
2538
2545 @Override
2546 public void removeByT_CPK(long tableId, long classPK)
2547 throws SystemException {
2548 for (ExpandoValue expandoValue : findByT_CPK(tableId, classPK,
2549 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
2550 remove(expandoValue);
2551 }
2552 }
2553
2554
2562 @Override
2563 public int countByT_CPK(long tableId, long classPK)
2564 throws SystemException {
2565 FinderPath finderPath = FINDER_PATH_COUNT_BY_T_CPK;
2566
2567 Object[] finderArgs = new Object[] { tableId, classPK };
2568
2569 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
2570 this);
2571
2572 if (count == null) {
2573 StringBundler query = new StringBundler(3);
2574
2575 query.append(_SQL_COUNT_EXPANDOVALUE_WHERE);
2576
2577 query.append(_FINDER_COLUMN_T_CPK_TABLEID_2);
2578
2579 query.append(_FINDER_COLUMN_T_CPK_CLASSPK_2);
2580
2581 String sql = query.toString();
2582
2583 Session session = null;
2584
2585 try {
2586 session = openSession();
2587
2588 Query q = session.createQuery(sql);
2589
2590 QueryPos qPos = QueryPos.getInstance(q);
2591
2592 qPos.add(tableId);
2593
2594 qPos.add(classPK);
2595
2596 count = (Long)q.uniqueResult();
2597
2598 FinderCacheUtil.putResult(finderPath, finderArgs, count);
2599 }
2600 catch (Exception e) {
2601 FinderCacheUtil.removeResult(finderPath, finderArgs);
2602
2603 throw processException(e);
2604 }
2605 finally {
2606 closeSession(session);
2607 }
2608 }
2609
2610 return count.intValue();
2611 }
2612
2613 private static final String _FINDER_COLUMN_T_CPK_TABLEID_2 = "expandoValue.tableId = ? AND ";
2614 private static final String _FINDER_COLUMN_T_CPK_CLASSPK_2 = "expandoValue.classPK = ?";
2615 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_T_R = new FinderPath(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
2616 ExpandoValueModelImpl.FINDER_CACHE_ENABLED, ExpandoValueImpl.class,
2617 FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByT_R",
2618 new String[] {
2619 Long.class.getName(), Long.class.getName(),
2620
2621 Integer.class.getName(), Integer.class.getName(),
2622 OrderByComparator.class.getName()
2623 });
2624 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_T_R = new FinderPath(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
2625 ExpandoValueModelImpl.FINDER_CACHE_ENABLED, ExpandoValueImpl.class,
2626 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByT_R",
2627 new String[] { Long.class.getName(), Long.class.getName() },
2628 ExpandoValueModelImpl.TABLEID_COLUMN_BITMASK |
2629 ExpandoValueModelImpl.ROWID_COLUMN_BITMASK |
2630 ExpandoValueModelImpl.COLUMNID_COLUMN_BITMASK);
2631 public static final FinderPath FINDER_PATH_COUNT_BY_T_R = new FinderPath(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
2632 ExpandoValueModelImpl.FINDER_CACHE_ENABLED, Long.class,
2633 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByT_R",
2634 new String[] { Long.class.getName(), Long.class.getName() });
2635
2636
2644 @Override
2645 public List<ExpandoValue> findByT_R(long tableId, long rowId)
2646 throws SystemException {
2647 return findByT_R(tableId, rowId, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
2648 null);
2649 }
2650
2651
2665 @Override
2666 public List<ExpandoValue> findByT_R(long tableId, long rowId, int start,
2667 int end) throws SystemException {
2668 return findByT_R(tableId, rowId, start, end, null);
2669 }
2670
2671
2686 @Override
2687 public List<ExpandoValue> findByT_R(long tableId, long rowId, int start,
2688 int end, OrderByComparator orderByComparator) throws SystemException {
2689 boolean pagination = true;
2690 FinderPath finderPath = null;
2691 Object[] finderArgs = null;
2692
2693 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
2694 (orderByComparator == null)) {
2695 pagination = false;
2696 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_T_R;
2697 finderArgs = new Object[] { tableId, rowId };
2698 }
2699 else {
2700 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_T_R;
2701 finderArgs = new Object[] {
2702 tableId, rowId,
2703
2704 start, end, orderByComparator
2705 };
2706 }
2707
2708 List<ExpandoValue> list = (List<ExpandoValue>)FinderCacheUtil.getResult(finderPath,
2709 finderArgs, this);
2710
2711 if ((list != null) && !list.isEmpty()) {
2712 for (ExpandoValue expandoValue : list) {
2713 if ((tableId != expandoValue.getTableId()) ||
2714 (rowId != expandoValue.getRowId())) {
2715 list = null;
2716
2717 break;
2718 }
2719 }
2720 }
2721
2722 if (list == null) {
2723 StringBundler query = null;
2724
2725 if (orderByComparator != null) {
2726 query = new StringBundler(4 +
2727 (orderByComparator.getOrderByFields().length * 3));
2728 }
2729 else {
2730 query = new StringBundler(4);
2731 }
2732
2733 query.append(_SQL_SELECT_EXPANDOVALUE_WHERE);
2734
2735 query.append(_FINDER_COLUMN_T_R_TABLEID_2);
2736
2737 query.append(_FINDER_COLUMN_T_R_ROWID_2);
2738
2739 if (orderByComparator != null) {
2740 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2741 orderByComparator);
2742 }
2743 else
2744 if (pagination) {
2745 query.append(ExpandoValueModelImpl.ORDER_BY_JPQL);
2746 }
2747
2748 String sql = query.toString();
2749
2750 Session session = null;
2751
2752 try {
2753 session = openSession();
2754
2755 Query q = session.createQuery(sql);
2756
2757 QueryPos qPos = QueryPos.getInstance(q);
2758
2759 qPos.add(tableId);
2760
2761 qPos.add(rowId);
2762
2763 if (!pagination) {
2764 list = (List<ExpandoValue>)QueryUtil.list(q, getDialect(),
2765 start, end, false);
2766
2767 Collections.sort(list);
2768
2769 list = new UnmodifiableList<ExpandoValue>(list);
2770 }
2771 else {
2772 list = (List<ExpandoValue>)QueryUtil.list(q, getDialect(),
2773 start, end);
2774 }
2775
2776 cacheResult(list);
2777
2778 FinderCacheUtil.putResult(finderPath, finderArgs, list);
2779 }
2780 catch (Exception e) {
2781 FinderCacheUtil.removeResult(finderPath, finderArgs);
2782
2783 throw processException(e);
2784 }
2785 finally {
2786 closeSession(session);
2787 }
2788 }
2789
2790 return list;
2791 }
2792
2793
2803 @Override
2804 public ExpandoValue findByT_R_First(long tableId, long rowId,
2805 OrderByComparator orderByComparator)
2806 throws NoSuchValueException, SystemException {
2807 ExpandoValue expandoValue = fetchByT_R_First(tableId, rowId,
2808 orderByComparator);
2809
2810 if (expandoValue != null) {
2811 return expandoValue;
2812 }
2813
2814 StringBundler msg = new StringBundler(6);
2815
2816 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2817
2818 msg.append("tableId=");
2819 msg.append(tableId);
2820
2821 msg.append(", rowId=");
2822 msg.append(rowId);
2823
2824 msg.append(StringPool.CLOSE_CURLY_BRACE);
2825
2826 throw new NoSuchValueException(msg.toString());
2827 }
2828
2829
2838 @Override
2839 public ExpandoValue fetchByT_R_First(long tableId, long rowId,
2840 OrderByComparator orderByComparator) throws SystemException {
2841 List<ExpandoValue> list = findByT_R(tableId, rowId, 0, 1,
2842 orderByComparator);
2843
2844 if (!list.isEmpty()) {
2845 return list.get(0);
2846 }
2847
2848 return null;
2849 }
2850
2851
2861 @Override
2862 public ExpandoValue findByT_R_Last(long tableId, long rowId,
2863 OrderByComparator orderByComparator)
2864 throws NoSuchValueException, SystemException {
2865 ExpandoValue expandoValue = fetchByT_R_Last(tableId, rowId,
2866 orderByComparator);
2867
2868 if (expandoValue != null) {
2869 return expandoValue;
2870 }
2871
2872 StringBundler msg = new StringBundler(6);
2873
2874 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2875
2876 msg.append("tableId=");
2877 msg.append(tableId);
2878
2879 msg.append(", rowId=");
2880 msg.append(rowId);
2881
2882 msg.append(StringPool.CLOSE_CURLY_BRACE);
2883
2884 throw new NoSuchValueException(msg.toString());
2885 }
2886
2887
2896 @Override
2897 public ExpandoValue fetchByT_R_Last(long tableId, long rowId,
2898 OrderByComparator orderByComparator) throws SystemException {
2899 int count = countByT_R(tableId, rowId);
2900
2901 if (count == 0) {
2902 return null;
2903 }
2904
2905 List<ExpandoValue> list = findByT_R(tableId, rowId, count - 1, count,
2906 orderByComparator);
2907
2908 if (!list.isEmpty()) {
2909 return list.get(0);
2910 }
2911
2912 return null;
2913 }
2914
2915
2926 @Override
2927 public ExpandoValue[] findByT_R_PrevAndNext(long valueId, long tableId,
2928 long rowId, OrderByComparator orderByComparator)
2929 throws NoSuchValueException, SystemException {
2930 ExpandoValue expandoValue = findByPrimaryKey(valueId);
2931
2932 Session session = null;
2933
2934 try {
2935 session = openSession();
2936
2937 ExpandoValue[] array = new ExpandoValueImpl[3];
2938
2939 array[0] = getByT_R_PrevAndNext(session, expandoValue, tableId,
2940 rowId, orderByComparator, true);
2941
2942 array[1] = expandoValue;
2943
2944 array[2] = getByT_R_PrevAndNext(session, expandoValue, tableId,
2945 rowId, orderByComparator, false);
2946
2947 return array;
2948 }
2949 catch (Exception e) {
2950 throw processException(e);
2951 }
2952 finally {
2953 closeSession(session);
2954 }
2955 }
2956
2957 protected ExpandoValue getByT_R_PrevAndNext(Session session,
2958 ExpandoValue expandoValue, long tableId, long rowId,
2959 OrderByComparator orderByComparator, boolean previous) {
2960 StringBundler query = null;
2961
2962 if (orderByComparator != null) {
2963 query = new StringBundler(6 +
2964 (orderByComparator.getOrderByFields().length * 6));
2965 }
2966 else {
2967 query = new StringBundler(3);
2968 }
2969
2970 query.append(_SQL_SELECT_EXPANDOVALUE_WHERE);
2971
2972 query.append(_FINDER_COLUMN_T_R_TABLEID_2);
2973
2974 query.append(_FINDER_COLUMN_T_R_ROWID_2);
2975
2976 if (orderByComparator != null) {
2977 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
2978
2979 if (orderByConditionFields.length > 0) {
2980 query.append(WHERE_AND);
2981 }
2982
2983 for (int i = 0; i < orderByConditionFields.length; i++) {
2984 query.append(_ORDER_BY_ENTITY_ALIAS);
2985 query.append(orderByConditionFields[i]);
2986
2987 if ((i + 1) < orderByConditionFields.length) {
2988 if (orderByComparator.isAscending() ^ previous) {
2989 query.append(WHERE_GREATER_THAN_HAS_NEXT);
2990 }
2991 else {
2992 query.append(WHERE_LESSER_THAN_HAS_NEXT);
2993 }
2994 }
2995 else {
2996 if (orderByComparator.isAscending() ^ previous) {
2997 query.append(WHERE_GREATER_THAN);
2998 }
2999 else {
3000 query.append(WHERE_LESSER_THAN);
3001 }
3002 }
3003 }
3004
3005 query.append(ORDER_BY_CLAUSE);
3006
3007 String[] orderByFields = orderByComparator.getOrderByFields();
3008
3009 for (int i = 0; i < orderByFields.length; i++) {
3010 query.append(_ORDER_BY_ENTITY_ALIAS);
3011 query.append(orderByFields[i]);
3012
3013 if ((i + 1) < orderByFields.length) {
3014 if (orderByComparator.isAscending() ^ previous) {
3015 query.append(ORDER_BY_ASC_HAS_NEXT);
3016 }
3017 else {
3018 query.append(ORDER_BY_DESC_HAS_NEXT);
3019 }
3020 }
3021 else {
3022 if (orderByComparator.isAscending() ^ previous) {
3023 query.append(ORDER_BY_ASC);
3024 }
3025 else {
3026 query.append(ORDER_BY_DESC);
3027 }
3028 }
3029 }
3030 }
3031 else {
3032 query.append(ExpandoValueModelImpl.ORDER_BY_JPQL);
3033 }
3034
3035 String sql = query.toString();
3036
3037 Query q = session.createQuery(sql);
3038
3039 q.setFirstResult(0);
3040 q.setMaxResults(2);
3041
3042 QueryPos qPos = QueryPos.getInstance(q);
3043
3044 qPos.add(tableId);
3045
3046 qPos.add(rowId);
3047
3048 if (orderByComparator != null) {
3049 Object[] values = orderByComparator.getOrderByConditionValues(expandoValue);
3050
3051 for (Object value : values) {
3052 qPos.add(value);
3053 }
3054 }
3055
3056 List<ExpandoValue> list = q.list();
3057
3058 if (list.size() == 2) {
3059 return list.get(1);
3060 }
3061 else {
3062 return null;
3063 }
3064 }
3065
3066
3073 @Override
3074 public void removeByT_R(long tableId, long rowId) throws SystemException {
3075 for (ExpandoValue expandoValue : findByT_R(tableId, rowId,
3076 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
3077 remove(expandoValue);
3078 }
3079 }
3080
3081
3089 @Override
3090 public int countByT_R(long tableId, long rowId) throws SystemException {
3091 FinderPath finderPath = FINDER_PATH_COUNT_BY_T_R;
3092
3093 Object[] finderArgs = new Object[] { tableId, rowId };
3094
3095 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
3096 this);
3097
3098 if (count == null) {
3099 StringBundler query = new StringBundler(3);
3100
3101 query.append(_SQL_COUNT_EXPANDOVALUE_WHERE);
3102
3103 query.append(_FINDER_COLUMN_T_R_TABLEID_2);
3104
3105 query.append(_FINDER_COLUMN_T_R_ROWID_2);
3106
3107 String sql = query.toString();
3108
3109 Session session = null;
3110
3111 try {
3112 session = openSession();
3113
3114 Query q = session.createQuery(sql);
3115
3116 QueryPos qPos = QueryPos.getInstance(q);
3117
3118 qPos.add(tableId);
3119
3120 qPos.add(rowId);
3121
3122 count = (Long)q.uniqueResult();
3123
3124 FinderCacheUtil.putResult(finderPath, finderArgs, count);
3125 }
3126 catch (Exception e) {
3127 FinderCacheUtil.removeResult(finderPath, finderArgs);
3128
3129 throw processException(e);
3130 }
3131 finally {
3132 closeSession(session);
3133 }
3134 }
3135
3136 return count.intValue();
3137 }
3138
3139 private static final String _FINDER_COLUMN_T_R_TABLEID_2 = "expandoValue.tableId = ? AND ";
3140 private static final String _FINDER_COLUMN_T_R_ROWID_2 = "expandoValue.rowId = ?";
3141 public static final FinderPath FINDER_PATH_FETCH_BY_C_R = new FinderPath(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
3142 ExpandoValueModelImpl.FINDER_CACHE_ENABLED, ExpandoValueImpl.class,
3143 FINDER_CLASS_NAME_ENTITY, "fetchByC_R",
3144 new String[] { Long.class.getName(), Long.class.getName() },
3145 ExpandoValueModelImpl.COLUMNID_COLUMN_BITMASK |
3146 ExpandoValueModelImpl.ROWID_COLUMN_BITMASK);
3147 public static final FinderPath FINDER_PATH_COUNT_BY_C_R = new FinderPath(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
3148 ExpandoValueModelImpl.FINDER_CACHE_ENABLED, Long.class,
3149 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByC_R",
3150 new String[] { Long.class.getName(), Long.class.getName() });
3151
3152
3161 @Override
3162 public ExpandoValue findByC_R(long columnId, long rowId)
3163 throws NoSuchValueException, SystemException {
3164 ExpandoValue expandoValue = fetchByC_R(columnId, rowId);
3165
3166 if (expandoValue == null) {
3167 StringBundler msg = new StringBundler(6);
3168
3169 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3170
3171 msg.append("columnId=");
3172 msg.append(columnId);
3173
3174 msg.append(", rowId=");
3175 msg.append(rowId);
3176
3177 msg.append(StringPool.CLOSE_CURLY_BRACE);
3178
3179 if (_log.isWarnEnabled()) {
3180 _log.warn(msg.toString());
3181 }
3182
3183 throw new NoSuchValueException(msg.toString());
3184 }
3185
3186 return expandoValue;
3187 }
3188
3189
3197 @Override
3198 public ExpandoValue fetchByC_R(long columnId, long rowId)
3199 throws SystemException {
3200 return fetchByC_R(columnId, rowId, true);
3201 }
3202
3203
3212 @Override
3213 public ExpandoValue fetchByC_R(long columnId, long rowId,
3214 boolean retrieveFromCache) throws SystemException {
3215 Object[] finderArgs = new Object[] { columnId, rowId };
3216
3217 Object result = null;
3218
3219 if (retrieveFromCache) {
3220 result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_C_R,
3221 finderArgs, this);
3222 }
3223
3224 if (result instanceof ExpandoValue) {
3225 ExpandoValue expandoValue = (ExpandoValue)result;
3226
3227 if ((columnId != expandoValue.getColumnId()) ||
3228 (rowId != expandoValue.getRowId())) {
3229 result = null;
3230 }
3231 }
3232
3233 if (result == null) {
3234 StringBundler query = new StringBundler(4);
3235
3236 query.append(_SQL_SELECT_EXPANDOVALUE_WHERE);
3237
3238 query.append(_FINDER_COLUMN_C_R_COLUMNID_2);
3239
3240 query.append(_FINDER_COLUMN_C_R_ROWID_2);
3241
3242 String sql = query.toString();
3243
3244 Session session = null;
3245
3246 try {
3247 session = openSession();
3248
3249 Query q = session.createQuery(sql);
3250
3251 QueryPos qPos = QueryPos.getInstance(q);
3252
3253 qPos.add(columnId);
3254
3255 qPos.add(rowId);
3256
3257 List<ExpandoValue> list = q.list();
3258
3259 if (list.isEmpty()) {
3260 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_R,
3261 finderArgs, list);
3262 }
3263 else {
3264 ExpandoValue expandoValue = list.get(0);
3265
3266 result = expandoValue;
3267
3268 cacheResult(expandoValue);
3269
3270 if ((expandoValue.getColumnId() != columnId) ||
3271 (expandoValue.getRowId() != rowId)) {
3272 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_R,
3273 finderArgs, expandoValue);
3274 }
3275 }
3276 }
3277 catch (Exception e) {
3278 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_R,
3279 finderArgs);
3280
3281 throw processException(e);
3282 }
3283 finally {
3284 closeSession(session);
3285 }
3286 }
3287
3288 if (result instanceof List<?>) {
3289 return null;
3290 }
3291 else {
3292 return (ExpandoValue)result;
3293 }
3294 }
3295
3296
3304 @Override
3305 public ExpandoValue removeByC_R(long columnId, long rowId)
3306 throws NoSuchValueException, SystemException {
3307 ExpandoValue expandoValue = findByC_R(columnId, rowId);
3308
3309 return remove(expandoValue);
3310 }
3311
3312
3320 @Override
3321 public int countByC_R(long columnId, long rowId) throws SystemException {
3322 FinderPath finderPath = FINDER_PATH_COUNT_BY_C_R;
3323
3324 Object[] finderArgs = new Object[] { columnId, rowId };
3325
3326 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
3327 this);
3328
3329 if (count == null) {
3330 StringBundler query = new StringBundler(3);
3331
3332 query.append(_SQL_COUNT_EXPANDOVALUE_WHERE);
3333
3334 query.append(_FINDER_COLUMN_C_R_COLUMNID_2);
3335
3336 query.append(_FINDER_COLUMN_C_R_ROWID_2);
3337
3338 String sql = query.toString();
3339
3340 Session session = null;
3341
3342 try {
3343 session = openSession();
3344
3345 Query q = session.createQuery(sql);
3346
3347 QueryPos qPos = QueryPos.getInstance(q);
3348
3349 qPos.add(columnId);
3350
3351 qPos.add(rowId);
3352
3353 count = (Long)q.uniqueResult();
3354
3355 FinderCacheUtil.putResult(finderPath, finderArgs, count);
3356 }
3357 catch (Exception e) {
3358 FinderCacheUtil.removeResult(finderPath, finderArgs);
3359
3360 throw processException(e);
3361 }
3362 finally {
3363 closeSession(session);
3364 }
3365 }
3366
3367 return count.intValue();
3368 }
3369
3370 private static final String _FINDER_COLUMN_C_R_COLUMNID_2 = "expandoValue.columnId = ? AND ";
3371 private static final String _FINDER_COLUMN_C_R_ROWID_2 = "expandoValue.rowId = ?";
3372 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_C_C = new FinderPath(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
3373 ExpandoValueModelImpl.FINDER_CACHE_ENABLED, ExpandoValueImpl.class,
3374 FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByC_C",
3375 new String[] {
3376 Long.class.getName(), Long.class.getName(),
3377
3378 Integer.class.getName(), Integer.class.getName(),
3379 OrderByComparator.class.getName()
3380 });
3381 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_C_C = new FinderPath(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
3382 ExpandoValueModelImpl.FINDER_CACHE_ENABLED, ExpandoValueImpl.class,
3383 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByC_C",
3384 new String[] { Long.class.getName(), Long.class.getName() },
3385 ExpandoValueModelImpl.CLASSNAMEID_COLUMN_BITMASK |
3386 ExpandoValueModelImpl.CLASSPK_COLUMN_BITMASK |
3387 ExpandoValueModelImpl.TABLEID_COLUMN_BITMASK |
3388 ExpandoValueModelImpl.ROWID_COLUMN_BITMASK |
3389 ExpandoValueModelImpl.COLUMNID_COLUMN_BITMASK);
3390 public static final FinderPath FINDER_PATH_COUNT_BY_C_C = new FinderPath(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
3391 ExpandoValueModelImpl.FINDER_CACHE_ENABLED, Long.class,
3392 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByC_C",
3393 new String[] { Long.class.getName(), Long.class.getName() });
3394
3395
3403 @Override
3404 public List<ExpandoValue> findByC_C(long classNameId, long classPK)
3405 throws SystemException {
3406 return findByC_C(classNameId, classPK, QueryUtil.ALL_POS,
3407 QueryUtil.ALL_POS, null);
3408 }
3409
3410
3424 @Override
3425 public List<ExpandoValue> findByC_C(long classNameId, long classPK,
3426 int start, int end) throws SystemException {
3427 return findByC_C(classNameId, classPK, start, end, null);
3428 }
3429
3430
3445 @Override
3446 public List<ExpandoValue> findByC_C(long classNameId, long classPK,
3447 int start, int end, OrderByComparator orderByComparator)
3448 throws SystemException {
3449 boolean pagination = true;
3450 FinderPath finderPath = null;
3451 Object[] finderArgs = null;
3452
3453 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
3454 (orderByComparator == null)) {
3455 pagination = false;
3456 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_C_C;
3457 finderArgs = new Object[] { classNameId, classPK };
3458 }
3459 else {
3460 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_C_C;
3461 finderArgs = new Object[] {
3462 classNameId, classPK,
3463
3464 start, end, orderByComparator
3465 };
3466 }
3467
3468 List<ExpandoValue> list = (List<ExpandoValue>)FinderCacheUtil.getResult(finderPath,
3469 finderArgs, this);
3470
3471 if ((list != null) && !list.isEmpty()) {
3472 for (ExpandoValue expandoValue : list) {
3473 if ((classNameId != expandoValue.getClassNameId()) ||
3474 (classPK != expandoValue.getClassPK())) {
3475 list = null;
3476
3477 break;
3478 }
3479 }
3480 }
3481
3482 if (list == null) {
3483 StringBundler query = null;
3484
3485 if (orderByComparator != null) {
3486 query = new StringBundler(4 +
3487 (orderByComparator.getOrderByFields().length * 3));
3488 }
3489 else {
3490 query = new StringBundler(4);
3491 }
3492
3493 query.append(_SQL_SELECT_EXPANDOVALUE_WHERE);
3494
3495 query.append(_FINDER_COLUMN_C_C_CLASSNAMEID_2);
3496
3497 query.append(_FINDER_COLUMN_C_C_CLASSPK_2);
3498
3499 if (orderByComparator != null) {
3500 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
3501 orderByComparator);
3502 }
3503 else
3504 if (pagination) {
3505 query.append(ExpandoValueModelImpl.ORDER_BY_JPQL);
3506 }
3507
3508 String sql = query.toString();
3509
3510 Session session = null;
3511
3512 try {
3513 session = openSession();
3514
3515 Query q = session.createQuery(sql);
3516
3517 QueryPos qPos = QueryPos.getInstance(q);
3518
3519 qPos.add(classNameId);
3520
3521 qPos.add(classPK);
3522
3523 if (!pagination) {
3524 list = (List<ExpandoValue>)QueryUtil.list(q, getDialect(),
3525 start, end, false);
3526
3527 Collections.sort(list);
3528
3529 list = new UnmodifiableList<ExpandoValue>(list);
3530 }
3531 else {
3532 list = (List<ExpandoValue>)QueryUtil.list(q, getDialect(),
3533 start, end);
3534 }
3535
3536 cacheResult(list);
3537
3538 FinderCacheUtil.putResult(finderPath, finderArgs, list);
3539 }
3540 catch (Exception e) {
3541 FinderCacheUtil.removeResult(finderPath, finderArgs);
3542
3543 throw processException(e);
3544 }
3545 finally {
3546 closeSession(session);
3547 }
3548 }
3549
3550 return list;
3551 }
3552
3553
3563 @Override
3564 public ExpandoValue findByC_C_First(long classNameId, long classPK,
3565 OrderByComparator orderByComparator)
3566 throws NoSuchValueException, SystemException {
3567 ExpandoValue expandoValue = fetchByC_C_First(classNameId, classPK,
3568 orderByComparator);
3569
3570 if (expandoValue != null) {
3571 return expandoValue;
3572 }
3573
3574 StringBundler msg = new StringBundler(6);
3575
3576 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3577
3578 msg.append("classNameId=");
3579 msg.append(classNameId);
3580
3581 msg.append(", classPK=");
3582 msg.append(classPK);
3583
3584 msg.append(StringPool.CLOSE_CURLY_BRACE);
3585
3586 throw new NoSuchValueException(msg.toString());
3587 }
3588
3589
3598 @Override
3599 public ExpandoValue fetchByC_C_First(long classNameId, long classPK,
3600 OrderByComparator orderByComparator) throws SystemException {
3601 List<ExpandoValue> list = findByC_C(classNameId, classPK, 0, 1,
3602 orderByComparator);
3603
3604 if (!list.isEmpty()) {
3605 return list.get(0);
3606 }
3607
3608 return null;
3609 }
3610
3611
3621 @Override
3622 public ExpandoValue findByC_C_Last(long classNameId, long classPK,
3623 OrderByComparator orderByComparator)
3624 throws NoSuchValueException, SystemException {
3625 ExpandoValue expandoValue = fetchByC_C_Last(classNameId, classPK,
3626 orderByComparator);
3627
3628 if (expandoValue != null) {
3629 return expandoValue;
3630 }
3631
3632 StringBundler msg = new StringBundler(6);
3633
3634 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3635
3636 msg.append("classNameId=");
3637 msg.append(classNameId);
3638
3639 msg.append(", classPK=");
3640 msg.append(classPK);
3641
3642 msg.append(StringPool.CLOSE_CURLY_BRACE);
3643
3644 throw new NoSuchValueException(msg.toString());
3645 }
3646
3647
3656 @Override
3657 public ExpandoValue fetchByC_C_Last(long classNameId, long classPK,
3658 OrderByComparator orderByComparator) throws SystemException {
3659 int count = countByC_C(classNameId, classPK);
3660
3661 if (count == 0) {
3662 return null;
3663 }
3664
3665 List<ExpandoValue> list = findByC_C(classNameId, classPK, count - 1,
3666 count, orderByComparator);
3667
3668 if (!list.isEmpty()) {
3669 return list.get(0);
3670 }
3671
3672 return null;
3673 }
3674
3675
3686 @Override
3687 public ExpandoValue[] findByC_C_PrevAndNext(long valueId, long classNameId,
3688 long classPK, OrderByComparator orderByComparator)
3689 throws NoSuchValueException, SystemException {
3690 ExpandoValue expandoValue = findByPrimaryKey(valueId);
3691
3692 Session session = null;
3693
3694 try {
3695 session = openSession();
3696
3697 ExpandoValue[] array = new ExpandoValueImpl[3];
3698
3699 array[0] = getByC_C_PrevAndNext(session, expandoValue, classNameId,
3700 classPK, orderByComparator, true);
3701
3702 array[1] = expandoValue;
3703
3704 array[2] = getByC_C_PrevAndNext(session, expandoValue, classNameId,
3705 classPK, orderByComparator, false);
3706
3707 return array;
3708 }
3709 catch (Exception e) {
3710 throw processException(e);
3711 }
3712 finally {
3713 closeSession(session);
3714 }
3715 }
3716
3717 protected ExpandoValue getByC_C_PrevAndNext(Session session,
3718 ExpandoValue expandoValue, long classNameId, long classPK,
3719 OrderByComparator orderByComparator, boolean previous) {
3720 StringBundler query = null;
3721
3722 if (orderByComparator != null) {
3723 query = new StringBundler(6 +
3724 (orderByComparator.getOrderByFields().length * 6));
3725 }
3726 else {
3727 query = new StringBundler(3);
3728 }
3729
3730 query.append(_SQL_SELECT_EXPANDOVALUE_WHERE);
3731
3732 query.append(_FINDER_COLUMN_C_C_CLASSNAMEID_2);
3733
3734 query.append(_FINDER_COLUMN_C_C_CLASSPK_2);
3735
3736 if (orderByComparator != null) {
3737 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
3738
3739 if (orderByConditionFields.length > 0) {
3740 query.append(WHERE_AND);
3741 }
3742
3743 for (int i = 0; i < orderByConditionFields.length; i++) {
3744 query.append(_ORDER_BY_ENTITY_ALIAS);
3745 query.append(orderByConditionFields[i]);
3746
3747 if ((i + 1) < orderByConditionFields.length) {
3748 if (orderByComparator.isAscending() ^ previous) {
3749 query.append(WHERE_GREATER_THAN_HAS_NEXT);
3750 }
3751 else {
3752 query.append(WHERE_LESSER_THAN_HAS_NEXT);
3753 }
3754 }
3755 else {
3756 if (orderByComparator.isAscending() ^ previous) {
3757 query.append(WHERE_GREATER_THAN);
3758 }
3759 else {
3760 query.append(WHERE_LESSER_THAN);
3761 }
3762 }
3763 }
3764
3765 query.append(ORDER_BY_CLAUSE);
3766
3767 String[] orderByFields = orderByComparator.getOrderByFields();
3768
3769 for (int i = 0; i < orderByFields.length; i++) {
3770 query.append(_ORDER_BY_ENTITY_ALIAS);
3771 query.append(orderByFields[i]);
3772
3773 if ((i + 1) < orderByFields.length) {
3774 if (orderByComparator.isAscending() ^ previous) {
3775 query.append(ORDER_BY_ASC_HAS_NEXT);
3776 }
3777 else {
3778 query.append(ORDER_BY_DESC_HAS_NEXT);
3779 }
3780 }
3781 else {
3782 if (orderByComparator.isAscending() ^ previous) {
3783 query.append(ORDER_BY_ASC);
3784 }
3785 else {
3786 query.append(ORDER_BY_DESC);
3787 }
3788 }
3789 }
3790 }
3791 else {
3792 query.append(ExpandoValueModelImpl.ORDER_BY_JPQL);
3793 }
3794
3795 String sql = query.toString();
3796
3797 Query q = session.createQuery(sql);
3798
3799 q.setFirstResult(0);
3800 q.setMaxResults(2);
3801
3802 QueryPos qPos = QueryPos.getInstance(q);
3803
3804 qPos.add(classNameId);
3805
3806 qPos.add(classPK);
3807
3808 if (orderByComparator != null) {
3809 Object[] values = orderByComparator.getOrderByConditionValues(expandoValue);
3810
3811 for (Object value : values) {
3812 qPos.add(value);
3813 }
3814 }
3815
3816 List<ExpandoValue> list = q.list();
3817
3818 if (list.size() == 2) {
3819 return list.get(1);
3820 }
3821 else {
3822 return null;
3823 }
3824 }
3825
3826
3833 @Override
3834 public void removeByC_C(long classNameId, long classPK)
3835 throws SystemException {
3836 for (ExpandoValue expandoValue : findByC_C(classNameId, classPK,
3837 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
3838 remove(expandoValue);
3839 }
3840 }
3841
3842
3850 @Override
3851 public int countByC_C(long classNameId, long classPK)
3852 throws SystemException {
3853 FinderPath finderPath = FINDER_PATH_COUNT_BY_C_C;
3854
3855 Object[] finderArgs = new Object[] { classNameId, classPK };
3856
3857 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
3858 this);
3859
3860 if (count == null) {
3861 StringBundler query = new StringBundler(3);
3862
3863 query.append(_SQL_COUNT_EXPANDOVALUE_WHERE);
3864
3865 query.append(_FINDER_COLUMN_C_C_CLASSNAMEID_2);
3866
3867 query.append(_FINDER_COLUMN_C_C_CLASSPK_2);
3868
3869 String sql = query.toString();
3870
3871 Session session = null;
3872
3873 try {
3874 session = openSession();
3875
3876 Query q = session.createQuery(sql);
3877
3878 QueryPos qPos = QueryPos.getInstance(q);
3879
3880 qPos.add(classNameId);
3881
3882 qPos.add(classPK);
3883
3884 count = (Long)q.uniqueResult();
3885
3886 FinderCacheUtil.putResult(finderPath, finderArgs, count);
3887 }
3888 catch (Exception e) {
3889 FinderCacheUtil.removeResult(finderPath, finderArgs);
3890
3891 throw processException(e);
3892 }
3893 finally {
3894 closeSession(session);
3895 }
3896 }
3897
3898 return count.intValue();
3899 }
3900
3901 private static final String _FINDER_COLUMN_C_C_CLASSNAMEID_2 = "expandoValue.classNameId = ? AND ";
3902 private static final String _FINDER_COLUMN_C_C_CLASSPK_2 = "expandoValue.classPK = ?";
3903 public static final FinderPath FINDER_PATH_FETCH_BY_T_C_C = new FinderPath(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
3904 ExpandoValueModelImpl.FINDER_CACHE_ENABLED, ExpandoValueImpl.class,
3905 FINDER_CLASS_NAME_ENTITY, "fetchByT_C_C",
3906 new String[] {
3907 Long.class.getName(), Long.class.getName(), Long.class.getName()
3908 },
3909 ExpandoValueModelImpl.TABLEID_COLUMN_BITMASK |
3910 ExpandoValueModelImpl.COLUMNID_COLUMN_BITMASK |
3911 ExpandoValueModelImpl.CLASSPK_COLUMN_BITMASK);
3912 public static final FinderPath FINDER_PATH_COUNT_BY_T_C_C = new FinderPath(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
3913 ExpandoValueModelImpl.FINDER_CACHE_ENABLED, Long.class,
3914 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByT_C_C",
3915 new String[] {
3916 Long.class.getName(), Long.class.getName(), Long.class.getName()
3917 });
3918
3919
3929 @Override
3930 public ExpandoValue findByT_C_C(long tableId, long columnId, long classPK)
3931 throws NoSuchValueException, SystemException {
3932 ExpandoValue expandoValue = fetchByT_C_C(tableId, columnId, classPK);
3933
3934 if (expandoValue == null) {
3935 StringBundler msg = new StringBundler(8);
3936
3937 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3938
3939 msg.append("tableId=");
3940 msg.append(tableId);
3941
3942 msg.append(", columnId=");
3943 msg.append(columnId);
3944
3945 msg.append(", classPK=");
3946 msg.append(classPK);
3947
3948 msg.append(StringPool.CLOSE_CURLY_BRACE);
3949
3950 if (_log.isWarnEnabled()) {
3951 _log.warn(msg.toString());
3952 }
3953
3954 throw new NoSuchValueException(msg.toString());
3955 }
3956
3957 return expandoValue;
3958 }
3959
3960
3969 @Override
3970 public ExpandoValue fetchByT_C_C(long tableId, long columnId, long classPK)
3971 throws SystemException {
3972 return fetchByT_C_C(tableId, columnId, classPK, true);
3973 }
3974
3975
3985 @Override
3986 public ExpandoValue fetchByT_C_C(long tableId, long columnId, long classPK,
3987 boolean retrieveFromCache) throws SystemException {
3988 Object[] finderArgs = new Object[] { tableId, columnId, classPK };
3989
3990 Object result = null;
3991
3992 if (retrieveFromCache) {
3993 result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_T_C_C,
3994 finderArgs, this);
3995 }
3996
3997 if (result instanceof ExpandoValue) {
3998 ExpandoValue expandoValue = (ExpandoValue)result;
3999
4000 if ((tableId != expandoValue.getTableId()) ||
4001 (columnId != expandoValue.getColumnId()) ||
4002 (classPK != expandoValue.getClassPK())) {
4003 result = null;
4004 }
4005 }
4006
4007 if (result == null) {
4008 StringBundler query = new StringBundler(5);
4009
4010 query.append(_SQL_SELECT_EXPANDOVALUE_WHERE);
4011
4012 query.append(_FINDER_COLUMN_T_C_C_TABLEID_2);
4013
4014 query.append(_FINDER_COLUMN_T_C_C_COLUMNID_2);
4015
4016 query.append(_FINDER_COLUMN_T_C_C_CLASSPK_2);
4017
4018 String sql = query.toString();
4019
4020 Session session = null;
4021
4022 try {
4023 session = openSession();
4024
4025 Query q = session.createQuery(sql);
4026
4027 QueryPos qPos = QueryPos.getInstance(q);
4028
4029 qPos.add(tableId);
4030
4031 qPos.add(columnId);
4032
4033 qPos.add(classPK);
4034
4035 List<ExpandoValue> list = q.list();
4036
4037 if (list.isEmpty()) {
4038 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_T_C_C,
4039 finderArgs, list);
4040 }
4041 else {
4042 ExpandoValue expandoValue = list.get(0);
4043
4044 result = expandoValue;
4045
4046 cacheResult(expandoValue);
4047
4048 if ((expandoValue.getTableId() != tableId) ||
4049 (expandoValue.getColumnId() != columnId) ||
4050 (expandoValue.getClassPK() != classPK)) {
4051 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_T_C_C,
4052 finderArgs, expandoValue);
4053 }
4054 }
4055 }
4056 catch (Exception e) {
4057 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_T_C_C,
4058 finderArgs);
4059
4060 throw processException(e);
4061 }
4062 finally {
4063 closeSession(session);
4064 }
4065 }
4066
4067 if (result instanceof List<?>) {
4068 return null;
4069 }
4070 else {
4071 return (ExpandoValue)result;
4072 }
4073 }
4074
4075
4084 @Override
4085 public ExpandoValue removeByT_C_C(long tableId, long columnId, long classPK)
4086 throws NoSuchValueException, SystemException {
4087 ExpandoValue expandoValue = findByT_C_C(tableId, columnId, classPK);
4088
4089 return remove(expandoValue);
4090 }
4091
4092
4101 @Override
4102 public int countByT_C_C(long tableId, long columnId, long classPK)
4103 throws SystemException {
4104 FinderPath finderPath = FINDER_PATH_COUNT_BY_T_C_C;
4105
4106 Object[] finderArgs = new Object[] { tableId, columnId, classPK };
4107
4108 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
4109 this);
4110
4111 if (count == null) {
4112 StringBundler query = new StringBundler(4);
4113
4114 query.append(_SQL_COUNT_EXPANDOVALUE_WHERE);
4115
4116 query.append(_FINDER_COLUMN_T_C_C_TABLEID_2);
4117
4118 query.append(_FINDER_COLUMN_T_C_C_COLUMNID_2);
4119
4120 query.append(_FINDER_COLUMN_T_C_C_CLASSPK_2);
4121
4122 String sql = query.toString();
4123
4124 Session session = null;
4125
4126 try {
4127 session = openSession();
4128
4129 Query q = session.createQuery(sql);
4130
4131 QueryPos qPos = QueryPos.getInstance(q);
4132
4133 qPos.add(tableId);
4134
4135 qPos.add(columnId);
4136
4137 qPos.add(classPK);
4138
4139 count = (Long)q.uniqueResult();
4140
4141 FinderCacheUtil.putResult(finderPath, finderArgs, count);
4142 }
4143 catch (Exception e) {
4144 FinderCacheUtil.removeResult(finderPath, finderArgs);
4145
4146 throw processException(e);
4147 }
4148 finally {
4149 closeSession(session);
4150 }
4151 }
4152
4153 return count.intValue();
4154 }
4155
4156 private static final String _FINDER_COLUMN_T_C_C_TABLEID_2 = "expandoValue.tableId = ? AND ";
4157 private static final String _FINDER_COLUMN_T_C_C_COLUMNID_2 = "expandoValue.columnId = ? AND ";
4158 private static final String _FINDER_COLUMN_T_C_C_CLASSPK_2 = "expandoValue.classPK = ?";
4159 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_T_C_D = new FinderPath(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
4160 ExpandoValueModelImpl.FINDER_CACHE_ENABLED, ExpandoValueImpl.class,
4161 FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByT_C_D",
4162 new String[] {
4163 Long.class.getName(), Long.class.getName(),
4164 String.class.getName(),
4165
4166 Integer.class.getName(), Integer.class.getName(),
4167 OrderByComparator.class.getName()
4168 });
4169 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_T_C_D = new FinderPath(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
4170 ExpandoValueModelImpl.FINDER_CACHE_ENABLED, ExpandoValueImpl.class,
4171 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByT_C_D",
4172 new String[] {
4173 Long.class.getName(), Long.class.getName(),
4174 String.class.getName()
4175 },
4176 ExpandoValueModelImpl.TABLEID_COLUMN_BITMASK |
4177 ExpandoValueModelImpl.COLUMNID_COLUMN_BITMASK |
4178 ExpandoValueModelImpl.DATA_COLUMN_BITMASK |
4179 ExpandoValueModelImpl.ROWID_COLUMN_BITMASK);
4180 public static final FinderPath FINDER_PATH_COUNT_BY_T_C_D = new FinderPath(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
4181 ExpandoValueModelImpl.FINDER_CACHE_ENABLED, Long.class,
4182 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByT_C_D",
4183 new String[] {
4184 Long.class.getName(), Long.class.getName(),
4185 String.class.getName()
4186 });
4187
4188
4197 @Override
4198 public List<ExpandoValue> findByT_C_D(long tableId, long columnId,
4199 String data) throws SystemException {
4200 return findByT_C_D(tableId, columnId, data, QueryUtil.ALL_POS,
4201 QueryUtil.ALL_POS, null);
4202 }
4203
4204
4219 @Override
4220 public List<ExpandoValue> findByT_C_D(long tableId, long columnId,
4221 String data, int start, int end) throws SystemException {
4222 return findByT_C_D(tableId, columnId, data, start, end, null);
4223 }
4224
4225
4241 @Override
4242 public List<ExpandoValue> findByT_C_D(long tableId, long columnId,
4243 String data, int start, int end, OrderByComparator orderByComparator)
4244 throws SystemException {
4245 boolean pagination = true;
4246 FinderPath finderPath = null;
4247 Object[] finderArgs = null;
4248
4249 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
4250 (orderByComparator == null)) {
4251 pagination = false;
4252 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_T_C_D;
4253 finderArgs = new Object[] { tableId, columnId, data };
4254 }
4255 else {
4256 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_T_C_D;
4257 finderArgs = new Object[] {
4258 tableId, columnId, data,
4259
4260 start, end, orderByComparator
4261 };
4262 }
4263
4264 List<ExpandoValue> list = (List<ExpandoValue>)FinderCacheUtil.getResult(finderPath,
4265 finderArgs, this);
4266
4267 if ((list != null) && !list.isEmpty()) {
4268 for (ExpandoValue expandoValue : list) {
4269 if ((tableId != expandoValue.getTableId()) ||
4270 (columnId != expandoValue.getColumnId()) ||
4271 !Validator.equals(data, expandoValue.getData())) {
4272 list = null;
4273
4274 break;
4275 }
4276 }
4277 }
4278
4279 if (list == null) {
4280 StringBundler query = null;
4281
4282 if (orderByComparator != null) {
4283 query = new StringBundler(5 +
4284 (orderByComparator.getOrderByFields().length * 3));
4285 }
4286 else {
4287 query = new StringBundler(5);
4288 }
4289
4290 query.append(_SQL_SELECT_EXPANDOVALUE_WHERE);
4291
4292 query.append(_FINDER_COLUMN_T_C_D_TABLEID_2);
4293
4294 query.append(_FINDER_COLUMN_T_C_D_COLUMNID_2);
4295
4296 boolean bindData = false;
4297
4298 if (data == null) {
4299 query.append(_FINDER_COLUMN_T_C_D_DATA_1);
4300 }
4301 else if (data.equals(StringPool.BLANK)) {
4302 query.append(_FINDER_COLUMN_T_C_D_DATA_3);
4303 }
4304 else {
4305 bindData = true;
4306
4307 query.append(_FINDER_COLUMN_T_C_D_DATA_2);
4308 }
4309
4310 if (orderByComparator != null) {
4311 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
4312 orderByComparator);
4313 }
4314 else
4315 if (pagination) {
4316 query.append(ExpandoValueModelImpl.ORDER_BY_JPQL);
4317 }
4318
4319 String sql = query.toString();
4320
4321 Session session = null;
4322
4323 try {
4324 session = openSession();
4325
4326 Query q = session.createQuery(sql);
4327
4328 QueryPos qPos = QueryPos.getInstance(q);
4329
4330 qPos.add(tableId);
4331
4332 qPos.add(columnId);
4333
4334 if (bindData) {
4335 qPos.add(data);
4336 }
4337
4338 if (!pagination) {
4339 list = (List<ExpandoValue>)QueryUtil.list(q, getDialect(),
4340 start, end, false);
4341
4342 Collections.sort(list);
4343
4344 list = new UnmodifiableList<ExpandoValue>(list);
4345 }
4346 else {
4347 list = (List<ExpandoValue>)QueryUtil.list(q, getDialect(),
4348 start, end);
4349 }
4350
4351 cacheResult(list);
4352
4353 FinderCacheUtil.putResult(finderPath, finderArgs, list);
4354 }
4355 catch (Exception e) {
4356 FinderCacheUtil.removeResult(finderPath, finderArgs);
4357
4358 throw processException(e);
4359 }
4360 finally {
4361 closeSession(session);
4362 }
4363 }
4364
4365 return list;
4366 }
4367
4368
4379 @Override
4380 public ExpandoValue findByT_C_D_First(long tableId, long columnId,
4381 String data, OrderByComparator orderByComparator)
4382 throws NoSuchValueException, SystemException {
4383 ExpandoValue expandoValue = fetchByT_C_D_First(tableId, columnId, data,
4384 orderByComparator);
4385
4386 if (expandoValue != null) {
4387 return expandoValue;
4388 }
4389
4390 StringBundler msg = new StringBundler(8);
4391
4392 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
4393
4394 msg.append("tableId=");
4395 msg.append(tableId);
4396
4397 msg.append(", columnId=");
4398 msg.append(columnId);
4399
4400 msg.append(", data=");
4401 msg.append(data);
4402
4403 msg.append(StringPool.CLOSE_CURLY_BRACE);
4404
4405 throw new NoSuchValueException(msg.toString());
4406 }
4407
4408
4418 @Override
4419 public ExpandoValue fetchByT_C_D_First(long tableId, long columnId,
4420 String data, OrderByComparator orderByComparator)
4421 throws SystemException {
4422 List<ExpandoValue> list = findByT_C_D(tableId, columnId, data, 0, 1,
4423 orderByComparator);
4424
4425 if (!list.isEmpty()) {
4426 return list.get(0);
4427 }
4428
4429 return null;
4430 }
4431
4432
4443 @Override
4444 public ExpandoValue findByT_C_D_Last(long tableId, long columnId,
4445 String data, OrderByComparator orderByComparator)
4446 throws NoSuchValueException, SystemException {
4447 ExpandoValue expandoValue = fetchByT_C_D_Last(tableId, columnId, data,
4448 orderByComparator);
4449
4450 if (expandoValue != null) {
4451 return expandoValue;
4452 }
4453
4454 StringBundler msg = new StringBundler(8);
4455
4456 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
4457
4458 msg.append("tableId=");
4459 msg.append(tableId);
4460
4461 msg.append(", columnId=");
4462 msg.append(columnId);
4463
4464 msg.append(", data=");
4465 msg.append(data);
4466
4467 msg.append(StringPool.CLOSE_CURLY_BRACE);
4468
4469 throw new NoSuchValueException(msg.toString());
4470 }
4471
4472
4482 @Override
4483 public ExpandoValue fetchByT_C_D_Last(long tableId, long columnId,
4484 String data, OrderByComparator orderByComparator)
4485 throws SystemException {
4486 int count = countByT_C_D(tableId, columnId, data);
4487
4488 if (count == 0) {
4489 return null;
4490 }
4491
4492 List<ExpandoValue> list = findByT_C_D(tableId, columnId, data,
4493 count - 1, count, orderByComparator);
4494
4495 if (!list.isEmpty()) {
4496 return list.get(0);
4497 }
4498
4499 return null;
4500 }
4501
4502
4514 @Override
4515 public ExpandoValue[] findByT_C_D_PrevAndNext(long valueId, long tableId,
4516 long columnId, String data, OrderByComparator orderByComparator)
4517 throws NoSuchValueException, SystemException {
4518 ExpandoValue expandoValue = findByPrimaryKey(valueId);
4519
4520 Session session = null;
4521
4522 try {
4523 session = openSession();
4524
4525 ExpandoValue[] array = new ExpandoValueImpl[3];
4526
4527 array[0] = getByT_C_D_PrevAndNext(session, expandoValue, tableId,
4528 columnId, data, orderByComparator, true);
4529
4530 array[1] = expandoValue;
4531
4532 array[2] = getByT_C_D_PrevAndNext(session, expandoValue, tableId,
4533 columnId, data, orderByComparator, false);
4534
4535 return array;
4536 }
4537 catch (Exception e) {
4538 throw processException(e);
4539 }
4540 finally {
4541 closeSession(session);
4542 }
4543 }
4544
4545 protected ExpandoValue getByT_C_D_PrevAndNext(Session session,
4546 ExpandoValue expandoValue, long tableId, long columnId, String data,
4547 OrderByComparator orderByComparator, boolean previous) {
4548 StringBundler query = null;
4549
4550 if (orderByComparator != null) {
4551 query = new StringBundler(6 +
4552 (orderByComparator.getOrderByFields().length * 6));
4553 }
4554 else {
4555 query = new StringBundler(3);
4556 }
4557
4558 query.append(_SQL_SELECT_EXPANDOVALUE_WHERE);
4559
4560 query.append(_FINDER_COLUMN_T_C_D_TABLEID_2);
4561
4562 query.append(_FINDER_COLUMN_T_C_D_COLUMNID_2);
4563
4564 boolean bindData = false;
4565
4566 if (data == null) {
4567 query.append(_FINDER_COLUMN_T_C_D_DATA_1);
4568 }
4569 else if (data.equals(StringPool.BLANK)) {
4570 query.append(_FINDER_COLUMN_T_C_D_DATA_3);
4571 }
4572 else {
4573 bindData = true;
4574
4575 query.append(_FINDER_COLUMN_T_C_D_DATA_2);
4576 }
4577
4578 if (orderByComparator != null) {
4579 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
4580
4581 if (orderByConditionFields.length > 0) {
4582 query.append(WHERE_AND);
4583 }
4584
4585 for (int i = 0; i < orderByConditionFields.length; i++) {
4586 query.append(_ORDER_BY_ENTITY_ALIAS);
4587 query.append(orderByConditionFields[i]);
4588
4589 if ((i + 1) < orderByConditionFields.length) {
4590 if (orderByComparator.isAscending() ^ previous) {
4591 query.append(WHERE_GREATER_THAN_HAS_NEXT);
4592 }
4593 else {
4594 query.append(WHERE_LESSER_THAN_HAS_NEXT);
4595 }
4596 }
4597 else {
4598 if (orderByComparator.isAscending() ^ previous) {
4599 query.append(WHERE_GREATER_THAN);
4600 }
4601 else {
4602 query.append(WHERE_LESSER_THAN);
4603 }
4604 }
4605 }
4606
4607 query.append(ORDER_BY_CLAUSE);
4608
4609 String[] orderByFields = orderByComparator.getOrderByFields();
4610
4611 for (int i = 0; i < orderByFields.length; i++) {
4612 query.append(_ORDER_BY_ENTITY_ALIAS);
4613 query.append(orderByFields[i]);
4614
4615 if ((i + 1) < orderByFields.length) {
4616 if (orderByComparator.isAscending() ^ previous) {
4617 query.append(ORDER_BY_ASC_HAS_NEXT);
4618 }
4619 else {
4620 query.append(ORDER_BY_DESC_HAS_NEXT);
4621 }
4622 }
4623 else {
4624 if (orderByComparator.isAscending() ^ previous) {
4625 query.append(ORDER_BY_ASC);
4626 }
4627 else {
4628 query.append(ORDER_BY_DESC);
4629 }
4630 }
4631 }
4632 }
4633 else {
4634 query.append(ExpandoValueModelImpl.ORDER_BY_JPQL);
4635 }
4636
4637 String sql = query.toString();
4638
4639 Query q = session.createQuery(sql);
4640
4641 q.setFirstResult(0);
4642 q.setMaxResults(2);
4643
4644 QueryPos qPos = QueryPos.getInstance(q);
4645
4646 qPos.add(tableId);
4647
4648 qPos.add(columnId);
4649
4650 if (bindData) {
4651 qPos.add(data);
4652 }
4653
4654 if (orderByComparator != null) {
4655 Object[] values = orderByComparator.getOrderByConditionValues(expandoValue);
4656
4657 for (Object value : values) {
4658 qPos.add(value);
4659 }
4660 }
4661
4662 List<ExpandoValue> list = q.list();
4663
4664 if (list.size() == 2) {
4665 return list.get(1);
4666 }
4667 else {
4668 return null;
4669 }
4670 }
4671
4672
4680 @Override
4681 public void removeByT_C_D(long tableId, long columnId, String data)
4682 throws SystemException {
4683 for (ExpandoValue expandoValue : findByT_C_D(tableId, columnId, data,
4684 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
4685 remove(expandoValue);
4686 }
4687 }
4688
4689
4698 @Override
4699 public int countByT_C_D(long tableId, long columnId, String data)
4700 throws SystemException {
4701 FinderPath finderPath = FINDER_PATH_COUNT_BY_T_C_D;
4702
4703 Object[] finderArgs = new Object[] { tableId, columnId, data };
4704
4705 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
4706 this);
4707
4708 if (count == null) {
4709 StringBundler query = new StringBundler(4);
4710
4711 query.append(_SQL_COUNT_EXPANDOVALUE_WHERE);
4712
4713 query.append(_FINDER_COLUMN_T_C_D_TABLEID_2);
4714
4715 query.append(_FINDER_COLUMN_T_C_D_COLUMNID_2);
4716
4717 boolean bindData = false;
4718
4719 if (data == null) {
4720 query.append(_FINDER_COLUMN_T_C_D_DATA_1);
4721 }
4722 else if (data.equals(StringPool.BLANK)) {
4723 query.append(_FINDER_COLUMN_T_C_D_DATA_3);
4724 }
4725 else {
4726 bindData = true;
4727
4728 query.append(_FINDER_COLUMN_T_C_D_DATA_2);
4729 }
4730
4731 String sql = query.toString();
4732
4733 Session session = null;
4734
4735 try {
4736 session = openSession();
4737
4738 Query q = session.createQuery(sql);
4739
4740 QueryPos qPos = QueryPos.getInstance(q);
4741
4742 qPos.add(tableId);
4743
4744 qPos.add(columnId);
4745
4746 if (bindData) {
4747 qPos.add(data);
4748 }
4749
4750 count = (Long)q.uniqueResult();
4751
4752 FinderCacheUtil.putResult(finderPath, finderArgs, count);
4753 }
4754 catch (Exception e) {
4755 FinderCacheUtil.removeResult(finderPath, finderArgs);
4756
4757 throw processException(e);
4758 }
4759 finally {
4760 closeSession(session);
4761 }
4762 }
4763
4764 return count.intValue();
4765 }
4766
4767 private static final String _FINDER_COLUMN_T_C_D_TABLEID_2 = "expandoValue.tableId = ? AND ";
4768 private static final String _FINDER_COLUMN_T_C_D_COLUMNID_2 = "expandoValue.columnId = ? AND ";
4769 private static final String _FINDER_COLUMN_T_C_D_DATA_1 = "expandoValue.data IS NULL";
4770 private static final String _FINDER_COLUMN_T_C_D_DATA_2 = "expandoValue.data = ?";
4771 private static final String _FINDER_COLUMN_T_C_D_DATA_3 = "(expandoValue.data IS NULL OR expandoValue.data = '')";
4772
4773
4778 @Override
4779 public void cacheResult(ExpandoValue expandoValue) {
4780 EntityCacheUtil.putResult(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
4781 ExpandoValueImpl.class, expandoValue.getPrimaryKey(), expandoValue);
4782
4783 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_R,
4784 new Object[] { expandoValue.getColumnId(), expandoValue.getRowId() },
4785 expandoValue);
4786
4787 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_T_C_C,
4788 new Object[] {
4789 expandoValue.getTableId(), expandoValue.getColumnId(),
4790 expandoValue.getClassPK()
4791 }, expandoValue);
4792
4793 expandoValue.resetOriginalValues();
4794 }
4795
4796
4801 @Override
4802 public void cacheResult(List<ExpandoValue> expandoValues) {
4803 for (ExpandoValue expandoValue : expandoValues) {
4804 if (EntityCacheUtil.getResult(
4805 ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
4806 ExpandoValueImpl.class, expandoValue.getPrimaryKey()) == null) {
4807 cacheResult(expandoValue);
4808 }
4809 else {
4810 expandoValue.resetOriginalValues();
4811 }
4812 }
4813 }
4814
4815
4822 @Override
4823 public void clearCache() {
4824 if (_HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE) {
4825 CacheRegistryUtil.clear(ExpandoValueImpl.class.getName());
4826 }
4827
4828 EntityCacheUtil.clearCache(ExpandoValueImpl.class.getName());
4829
4830 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
4831 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
4832 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
4833 }
4834
4835
4842 @Override
4843 public void clearCache(ExpandoValue expandoValue) {
4844 EntityCacheUtil.removeResult(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
4845 ExpandoValueImpl.class, expandoValue.getPrimaryKey());
4846
4847 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
4848 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
4849
4850 clearUniqueFindersCache(expandoValue);
4851 }
4852
4853 @Override
4854 public void clearCache(List<ExpandoValue> expandoValues) {
4855 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
4856 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
4857
4858 for (ExpandoValue expandoValue : expandoValues) {
4859 EntityCacheUtil.removeResult(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
4860 ExpandoValueImpl.class, expandoValue.getPrimaryKey());
4861
4862 clearUniqueFindersCache(expandoValue);
4863 }
4864 }
4865
4866 protected void cacheUniqueFindersCache(ExpandoValue expandoValue) {
4867 if (expandoValue.isNew()) {
4868 Object[] args = new Object[] {
4869 expandoValue.getColumnId(), expandoValue.getRowId()
4870 };
4871
4872 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_R, args,
4873 Long.valueOf(1));
4874 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_R, args,
4875 expandoValue);
4876
4877 args = new Object[] {
4878 expandoValue.getTableId(), expandoValue.getColumnId(),
4879 expandoValue.getClassPK()
4880 };
4881
4882 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_T_C_C, args,
4883 Long.valueOf(1));
4884 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_T_C_C, args,
4885 expandoValue);
4886 }
4887 else {
4888 ExpandoValueModelImpl expandoValueModelImpl = (ExpandoValueModelImpl)expandoValue;
4889
4890 if ((expandoValueModelImpl.getColumnBitmask() &
4891 FINDER_PATH_FETCH_BY_C_R.getColumnBitmask()) != 0) {
4892 Object[] args = new Object[] {
4893 expandoValue.getColumnId(), expandoValue.getRowId()
4894 };
4895
4896 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_R, args,
4897 Long.valueOf(1));
4898 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_R, args,
4899 expandoValue);
4900 }
4901
4902 if ((expandoValueModelImpl.getColumnBitmask() &
4903 FINDER_PATH_FETCH_BY_T_C_C.getColumnBitmask()) != 0) {
4904 Object[] args = new Object[] {
4905 expandoValue.getTableId(), expandoValue.getColumnId(),
4906 expandoValue.getClassPK()
4907 };
4908
4909 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_T_C_C, args,
4910 Long.valueOf(1));
4911 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_T_C_C, args,
4912 expandoValue);
4913 }
4914 }
4915 }
4916
4917 protected void clearUniqueFindersCache(ExpandoValue expandoValue) {
4918 ExpandoValueModelImpl expandoValueModelImpl = (ExpandoValueModelImpl)expandoValue;
4919
4920 Object[] args = new Object[] {
4921 expandoValue.getColumnId(), expandoValue.getRowId()
4922 };
4923
4924 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_C_R, args);
4925 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_R, args);
4926
4927 if ((expandoValueModelImpl.getColumnBitmask() &
4928 FINDER_PATH_FETCH_BY_C_R.getColumnBitmask()) != 0) {
4929 args = new Object[] {
4930 expandoValueModelImpl.getOriginalColumnId(),
4931 expandoValueModelImpl.getOriginalRowId()
4932 };
4933
4934 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_C_R, args);
4935 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_R, args);
4936 }
4937
4938 args = new Object[] {
4939 expandoValue.getTableId(), expandoValue.getColumnId(),
4940 expandoValue.getClassPK()
4941 };
4942
4943 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_T_C_C, args);
4944 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_T_C_C, args);
4945
4946 if ((expandoValueModelImpl.getColumnBitmask() &
4947 FINDER_PATH_FETCH_BY_T_C_C.getColumnBitmask()) != 0) {
4948 args = new Object[] {
4949 expandoValueModelImpl.getOriginalTableId(),
4950 expandoValueModelImpl.getOriginalColumnId(),
4951 expandoValueModelImpl.getOriginalClassPK()
4952 };
4953
4954 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_T_C_C, args);
4955 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_T_C_C, args);
4956 }
4957 }
4958
4959
4965 @Override
4966 public ExpandoValue create(long valueId) {
4967 ExpandoValue expandoValue = new ExpandoValueImpl();
4968
4969 expandoValue.setNew(true);
4970 expandoValue.setPrimaryKey(valueId);
4971
4972 return expandoValue;
4973 }
4974
4975
4983 @Override
4984 public ExpandoValue remove(long valueId)
4985 throws NoSuchValueException, SystemException {
4986 return remove((Serializable)valueId);
4987 }
4988
4989
4997 @Override
4998 public ExpandoValue remove(Serializable primaryKey)
4999 throws NoSuchValueException, SystemException {
5000 Session session = null;
5001
5002 try {
5003 session = openSession();
5004
5005 ExpandoValue expandoValue = (ExpandoValue)session.get(ExpandoValueImpl.class,
5006 primaryKey);
5007
5008 if (expandoValue == null) {
5009 if (_log.isWarnEnabled()) {
5010 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey);
5011 }
5012
5013 throw new NoSuchValueException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
5014 primaryKey);
5015 }
5016
5017 return remove(expandoValue);
5018 }
5019 catch (NoSuchValueException nsee) {
5020 throw nsee;
5021 }
5022 catch (Exception e) {
5023 throw processException(e);
5024 }
5025 finally {
5026 closeSession(session);
5027 }
5028 }
5029
5030 @Override
5031 protected ExpandoValue removeImpl(ExpandoValue expandoValue)
5032 throws SystemException {
5033 expandoValue = toUnwrappedModel(expandoValue);
5034
5035 Session session = null;
5036
5037 try {
5038 session = openSession();
5039
5040 if (!session.contains(expandoValue)) {
5041 expandoValue = (ExpandoValue)session.get(ExpandoValueImpl.class,
5042 expandoValue.getPrimaryKeyObj());
5043 }
5044
5045 if (expandoValue != null) {
5046 session.delete(expandoValue);
5047 }
5048 }
5049 catch (Exception e) {
5050 throw processException(e);
5051 }
5052 finally {
5053 closeSession(session);
5054 }
5055
5056 if (expandoValue != null) {
5057 clearCache(expandoValue);
5058 }
5059
5060 return expandoValue;
5061 }
5062
5063 @Override
5064 public ExpandoValue updateImpl(
5065 com.liferay.portlet.expando.model.ExpandoValue expandoValue)
5066 throws SystemException {
5067 expandoValue = toUnwrappedModel(expandoValue);
5068
5069 boolean isNew = expandoValue.isNew();
5070
5071 ExpandoValueModelImpl expandoValueModelImpl = (ExpandoValueModelImpl)expandoValue;
5072
5073 Session session = null;
5074
5075 try {
5076 session = openSession();
5077
5078 if (expandoValue.isNew()) {
5079 session.save(expandoValue);
5080
5081 expandoValue.setNew(false);
5082 }
5083 else {
5084 session.merge(expandoValue);
5085 }
5086 }
5087 catch (Exception e) {
5088 throw processException(e);
5089 }
5090 finally {
5091 closeSession(session);
5092 }
5093
5094 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
5095
5096 if (isNew || !ExpandoValueModelImpl.COLUMN_BITMASK_ENABLED) {
5097 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
5098 }
5099
5100 else {
5101 if ((expandoValueModelImpl.getColumnBitmask() &
5102 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_TABLEID.getColumnBitmask()) != 0) {
5103 Object[] args = new Object[] {
5104 expandoValueModelImpl.getOriginalTableId()
5105 };
5106
5107 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_TABLEID, args);
5108 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_TABLEID,
5109 args);
5110
5111 args = new Object[] { expandoValueModelImpl.getTableId() };
5112
5113 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_TABLEID, args);
5114 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_TABLEID,
5115 args);
5116 }
5117
5118 if ((expandoValueModelImpl.getColumnBitmask() &
5119 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_COLUMNID.getColumnBitmask()) != 0) {
5120 Object[] args = new Object[] {
5121 expandoValueModelImpl.getOriginalColumnId()
5122 };
5123
5124 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_COLUMNID, args);
5125 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_COLUMNID,
5126 args);
5127
5128 args = new Object[] { expandoValueModelImpl.getColumnId() };
5129
5130 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_COLUMNID, args);
5131 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_COLUMNID,
5132 args);
5133 }
5134
5135 if ((expandoValueModelImpl.getColumnBitmask() &
5136 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_ROWID.getColumnBitmask()) != 0) {
5137 Object[] args = new Object[] {
5138 expandoValueModelImpl.getOriginalRowId()
5139 };
5140
5141 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_ROWID, args);
5142 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_ROWID,
5143 args);
5144
5145 args = new Object[] { expandoValueModelImpl.getRowId() };
5146
5147 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_ROWID, args);
5148 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_ROWID,
5149 args);
5150 }
5151
5152 if ((expandoValueModelImpl.getColumnBitmask() &
5153 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_T_C.getColumnBitmask()) != 0) {
5154 Object[] args = new Object[] {
5155 expandoValueModelImpl.getOriginalTableId(),
5156 expandoValueModelImpl.getOriginalColumnId()
5157 };
5158
5159 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_T_C, args);
5160 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_T_C,
5161 args);
5162
5163 args = new Object[] {
5164 expandoValueModelImpl.getTableId(),
5165 expandoValueModelImpl.getColumnId()
5166 };
5167
5168 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_T_C, args);
5169 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_T_C,
5170 args);
5171 }
5172
5173 if ((expandoValueModelImpl.getColumnBitmask() &
5174 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_T_CPK.getColumnBitmask()) != 0) {
5175 Object[] args = new Object[] {
5176 expandoValueModelImpl.getOriginalTableId(),
5177 expandoValueModelImpl.getOriginalClassPK()
5178 };
5179
5180 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_T_CPK, args);
5181 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_T_CPK,
5182 args);
5183
5184 args = new Object[] {
5185 expandoValueModelImpl.getTableId(),
5186 expandoValueModelImpl.getClassPK()
5187 };
5188
5189 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_T_CPK, args);
5190 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_T_CPK,
5191 args);
5192 }
5193
5194 if ((expandoValueModelImpl.getColumnBitmask() &
5195 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_T_R.getColumnBitmask()) != 0) {
5196 Object[] args = new Object[] {
5197 expandoValueModelImpl.getOriginalTableId(),
5198 expandoValueModelImpl.getOriginalRowId()
5199 };
5200
5201 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_T_R, args);
5202 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_T_R,
5203 args);
5204
5205 args = new Object[] {
5206 expandoValueModelImpl.getTableId(),
5207 expandoValueModelImpl.getRowId()
5208 };
5209
5210 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_T_R, args);
5211 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_T_R,
5212 args);
5213 }
5214
5215 if ((expandoValueModelImpl.getColumnBitmask() &
5216 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_C_C.getColumnBitmask()) != 0) {
5217 Object[] args = new Object[] {
5218 expandoValueModelImpl.getOriginalClassNameId(),
5219 expandoValueModelImpl.getOriginalClassPK()
5220 };
5221
5222 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_C_C, args);
5223 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_C_C,
5224 args);
5225
5226 args = new Object[] {
5227 expandoValueModelImpl.getClassNameId(),
5228 expandoValueModelImpl.getClassPK()
5229 };
5230
5231 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_C_C, args);
5232 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_C_C,
5233 args);
5234 }
5235
5236 if ((expandoValueModelImpl.getColumnBitmask() &
5237 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_T_C_D.getColumnBitmask()) != 0) {
5238 Object[] args = new Object[] {
5239 expandoValueModelImpl.getOriginalTableId(),
5240 expandoValueModelImpl.getOriginalColumnId(),
5241 expandoValueModelImpl.getOriginalData()
5242 };
5243
5244 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_T_C_D, args);
5245 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_T_C_D,
5246 args);
5247
5248 args = new Object[] {
5249 expandoValueModelImpl.getTableId(),
5250 expandoValueModelImpl.getColumnId(),
5251 expandoValueModelImpl.getData()
5252 };
5253
5254 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_T_C_D, args);
5255 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_T_C_D,
5256 args);
5257 }
5258 }
5259
5260 EntityCacheUtil.putResult(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
5261 ExpandoValueImpl.class, expandoValue.getPrimaryKey(), expandoValue);
5262
5263 clearUniqueFindersCache(expandoValue);
5264 cacheUniqueFindersCache(expandoValue);
5265
5266 return expandoValue;
5267 }
5268
5269 protected ExpandoValue toUnwrappedModel(ExpandoValue expandoValue) {
5270 if (expandoValue instanceof ExpandoValueImpl) {
5271 return expandoValue;
5272 }
5273
5274 ExpandoValueImpl expandoValueImpl = new ExpandoValueImpl();
5275
5276 expandoValueImpl.setNew(expandoValue.isNew());
5277 expandoValueImpl.setPrimaryKey(expandoValue.getPrimaryKey());
5278
5279 expandoValueImpl.setValueId(expandoValue.getValueId());
5280 expandoValueImpl.setCompanyId(expandoValue.getCompanyId());
5281 expandoValueImpl.setTableId(expandoValue.getTableId());
5282 expandoValueImpl.setColumnId(expandoValue.getColumnId());
5283 expandoValueImpl.setRowId(expandoValue.getRowId());
5284 expandoValueImpl.setClassNameId(expandoValue.getClassNameId());
5285 expandoValueImpl.setClassPK(expandoValue.getClassPK());
5286 expandoValueImpl.setData(expandoValue.getData());
5287
5288 return expandoValueImpl;
5289 }
5290
5291
5299 @Override
5300 public ExpandoValue findByPrimaryKey(Serializable primaryKey)
5301 throws NoSuchValueException, SystemException {
5302 ExpandoValue expandoValue = fetchByPrimaryKey(primaryKey);
5303
5304 if (expandoValue == null) {
5305 if (_log.isWarnEnabled()) {
5306 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey);
5307 }
5308
5309 throw new NoSuchValueException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
5310 primaryKey);
5311 }
5312
5313 return expandoValue;
5314 }
5315
5316
5324 @Override
5325 public ExpandoValue findByPrimaryKey(long valueId)
5326 throws NoSuchValueException, SystemException {
5327 return findByPrimaryKey((Serializable)valueId);
5328 }
5329
5330
5337 @Override
5338 public ExpandoValue fetchByPrimaryKey(Serializable primaryKey)
5339 throws SystemException {
5340 ExpandoValue expandoValue = (ExpandoValue)EntityCacheUtil.getResult(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
5341 ExpandoValueImpl.class, primaryKey);
5342
5343 if (expandoValue == _nullExpandoValue) {
5344 return null;
5345 }
5346
5347 if (expandoValue == null) {
5348 Session session = null;
5349
5350 try {
5351 session = openSession();
5352
5353 expandoValue = (ExpandoValue)session.get(ExpandoValueImpl.class,
5354 primaryKey);
5355
5356 if (expandoValue != null) {
5357 cacheResult(expandoValue);
5358 }
5359 else {
5360 EntityCacheUtil.putResult(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
5361 ExpandoValueImpl.class, primaryKey, _nullExpandoValue);
5362 }
5363 }
5364 catch (Exception e) {
5365 EntityCacheUtil.removeResult(ExpandoValueModelImpl.ENTITY_CACHE_ENABLED,
5366 ExpandoValueImpl.class, primaryKey);
5367
5368 throw processException(e);
5369 }
5370 finally {
5371 closeSession(session);
5372 }
5373 }
5374
5375 return expandoValue;
5376 }
5377
5378
5385 @Override
5386 public ExpandoValue fetchByPrimaryKey(long valueId)
5387 throws SystemException {
5388 return fetchByPrimaryKey((Serializable)valueId);
5389 }
5390
5391
5397 @Override
5398 public List<ExpandoValue> findAll() throws SystemException {
5399 return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
5400 }
5401
5402
5414 @Override
5415 public List<ExpandoValue> findAll(int start, int end)
5416 throws SystemException {
5417 return findAll(start, end, null);
5418 }
5419
5420
5433 @Override
5434 public List<ExpandoValue> findAll(int start, int end,
5435 OrderByComparator orderByComparator) throws SystemException {
5436 boolean pagination = true;
5437 FinderPath finderPath = null;
5438 Object[] finderArgs = null;
5439
5440 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
5441 (orderByComparator == null)) {
5442 pagination = false;
5443 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL;
5444 finderArgs = FINDER_ARGS_EMPTY;
5445 }
5446 else {
5447 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_ALL;
5448 finderArgs = new Object[] { start, end, orderByComparator };
5449 }
5450
5451 List<ExpandoValue> list = (List<ExpandoValue>)FinderCacheUtil.getResult(finderPath,
5452 finderArgs, this);
5453
5454 if (list == null) {
5455 StringBundler query = null;
5456 String sql = null;
5457
5458 if (orderByComparator != null) {
5459 query = new StringBundler(2 +
5460 (orderByComparator.getOrderByFields().length * 3));
5461
5462 query.append(_SQL_SELECT_EXPANDOVALUE);
5463
5464 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
5465 orderByComparator);
5466
5467 sql = query.toString();
5468 }
5469 else {
5470 sql = _SQL_SELECT_EXPANDOVALUE;
5471
5472 if (pagination) {
5473 sql = sql.concat(ExpandoValueModelImpl.ORDER_BY_JPQL);
5474 }
5475 }
5476
5477 Session session = null;
5478
5479 try {
5480 session = openSession();
5481
5482 Query q = session.createQuery(sql);
5483
5484 if (!pagination) {
5485 list = (List<ExpandoValue>)QueryUtil.list(q, getDialect(),
5486 start, end, false);
5487
5488 Collections.sort(list);
5489
5490 list = new UnmodifiableList<ExpandoValue>(list);
5491 }
5492 else {
5493 list = (List<ExpandoValue>)QueryUtil.list(q, getDialect(),
5494 start, end);
5495 }
5496
5497 cacheResult(list);
5498
5499 FinderCacheUtil.putResult(finderPath, finderArgs, list);
5500 }
5501 catch (Exception e) {
5502 FinderCacheUtil.removeResult(finderPath, finderArgs);
5503
5504 throw processException(e);
5505 }
5506 finally {
5507 closeSession(session);
5508 }
5509 }
5510
5511 return list;
5512 }
5513
5514
5519 @Override
5520 public void removeAll() throws SystemException {
5521 for (ExpandoValue expandoValue : findAll()) {
5522 remove(expandoValue);
5523 }
5524 }
5525
5526
5532 @Override
5533 public int countAll() throws SystemException {
5534 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
5535 FINDER_ARGS_EMPTY, this);
5536
5537 if (count == null) {
5538 Session session = null;
5539
5540 try {
5541 session = openSession();
5542
5543 Query q = session.createQuery(_SQL_COUNT_EXPANDOVALUE);
5544
5545 count = (Long)q.uniqueResult();
5546
5547 FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL,
5548 FINDER_ARGS_EMPTY, count);
5549 }
5550 catch (Exception e) {
5551 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_ALL,
5552 FINDER_ARGS_EMPTY);
5553
5554 throw processException(e);
5555 }
5556 finally {
5557 closeSession(session);
5558 }
5559 }
5560
5561 return count.intValue();
5562 }
5563
5564 @Override
5565 protected Set<String> getBadColumnNames() {
5566 return _badColumnNames;
5567 }
5568
5569
5572 public void afterPropertiesSet() {
5573 String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
5574 com.liferay.portal.util.PropsUtil.get(
5575 "value.object.listener.com.liferay.portlet.expando.model.ExpandoValue")));
5576
5577 if (listenerClassNames.length > 0) {
5578 try {
5579 List<ModelListener<ExpandoValue>> listenersList = new ArrayList<ModelListener<ExpandoValue>>();
5580
5581 for (String listenerClassName : listenerClassNames) {
5582 listenersList.add((ModelListener<ExpandoValue>)InstanceFactory.newInstance(
5583 getClassLoader(), listenerClassName));
5584 }
5585
5586 listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
5587 }
5588 catch (Exception e) {
5589 _log.error(e);
5590 }
5591 }
5592 }
5593
5594 public void destroy() {
5595 EntityCacheUtil.removeCache(ExpandoValueImpl.class.getName());
5596 FinderCacheUtil.removeCache(FINDER_CLASS_NAME_ENTITY);
5597 FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
5598 FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
5599 }
5600
5601 private static final String _SQL_SELECT_EXPANDOVALUE = "SELECT expandoValue FROM ExpandoValue expandoValue";
5602 private static final String _SQL_SELECT_EXPANDOVALUE_WHERE = "SELECT expandoValue FROM ExpandoValue expandoValue WHERE ";
5603 private static final String _SQL_COUNT_EXPANDOVALUE = "SELECT COUNT(expandoValue) FROM ExpandoValue expandoValue";
5604 private static final String _SQL_COUNT_EXPANDOVALUE_WHERE = "SELECT COUNT(expandoValue) FROM ExpandoValue expandoValue WHERE ";
5605 private static final String _ORDER_BY_ENTITY_ALIAS = "expandoValue.";
5606 private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No ExpandoValue exists with the primary key ";
5607 private static final String _NO_SUCH_ENTITY_WITH_KEY = "No ExpandoValue exists with the key {";
5608 private static final boolean _HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE = com.liferay.portal.util.PropsValues.HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE;
5609 private static Log _log = LogFactoryUtil.getLog(ExpandoValuePersistenceImpl.class);
5610 private static Set<String> _badColumnNames = SetUtil.fromArray(new String[] {
5611 "rowId", "data"
5612 });
5613 private static ExpandoValue _nullExpandoValue = new ExpandoValueImpl() {
5614 @Override
5615 public Object clone() {
5616 return this;
5617 }
5618
5619 @Override
5620 public CacheModel<ExpandoValue> toCacheModel() {
5621 return _nullExpandoValueCacheModel;
5622 }
5623 };
5624
5625 private static CacheModel<ExpandoValue> _nullExpandoValueCacheModel = new CacheModel<ExpandoValue>() {
5626 @Override
5627 public ExpandoValue toEntityModel() {
5628 return _nullExpandoValue;
5629 }
5630 };
5631 }