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.SQLQuery;
025 import com.liferay.portal.kernel.dao.orm.Session;
026 import com.liferay.portal.kernel.exception.SystemException;
027 import com.liferay.portal.kernel.log.Log;
028 import com.liferay.portal.kernel.log.LogFactoryUtil;
029 import com.liferay.portal.kernel.util.ArrayUtil;
030 import com.liferay.portal.kernel.util.GetterUtil;
031 import com.liferay.portal.kernel.util.InstanceFactory;
032 import com.liferay.portal.kernel.util.OrderByComparator;
033 import com.liferay.portal.kernel.util.SetUtil;
034 import com.liferay.portal.kernel.util.StringBundler;
035 import com.liferay.portal.kernel.util.StringPool;
036 import com.liferay.portal.kernel.util.StringUtil;
037 import com.liferay.portal.kernel.util.UnmodifiableList;
038 import com.liferay.portal.kernel.util.Validator;
039 import com.liferay.portal.model.CacheModel;
040 import com.liferay.portal.model.ModelListener;
041 import com.liferay.portal.security.permission.InlineSQLHelperUtil;
042 import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
043
044 import com.liferay.portlet.expando.NoSuchColumnException;
045 import com.liferay.portlet.expando.model.ExpandoColumn;
046 import com.liferay.portlet.expando.model.impl.ExpandoColumnImpl;
047 import com.liferay.portlet.expando.model.impl.ExpandoColumnModelImpl;
048
049 import java.io.Serializable;
050
051 import java.util.ArrayList;
052 import java.util.Collections;
053 import java.util.List;
054 import java.util.Set;
055
056
068 public class ExpandoColumnPersistenceImpl extends BasePersistenceImpl<ExpandoColumn>
069 implements ExpandoColumnPersistence {
070
075 public static final String FINDER_CLASS_NAME_ENTITY = ExpandoColumnImpl.class.getName();
076 public static final String FINDER_CLASS_NAME_LIST_WITH_PAGINATION = FINDER_CLASS_NAME_ENTITY +
077 ".List1";
078 public static final String FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION = FINDER_CLASS_NAME_ENTITY +
079 ".List2";
080 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_ALL = new FinderPath(ExpandoColumnModelImpl.ENTITY_CACHE_ENABLED,
081 ExpandoColumnModelImpl.FINDER_CACHE_ENABLED,
082 ExpandoColumnImpl.class, FINDER_CLASS_NAME_LIST_WITH_PAGINATION,
083 "findAll", new String[0]);
084 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL = new FinderPath(ExpandoColumnModelImpl.ENTITY_CACHE_ENABLED,
085 ExpandoColumnModelImpl.FINDER_CACHE_ENABLED,
086 ExpandoColumnImpl.class, FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION,
087 "findAll", new String[0]);
088 public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(ExpandoColumnModelImpl.ENTITY_CACHE_ENABLED,
089 ExpandoColumnModelImpl.FINDER_CACHE_ENABLED, Long.class,
090 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countAll", new String[0]);
091 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_TABLEID = new FinderPath(ExpandoColumnModelImpl.ENTITY_CACHE_ENABLED,
092 ExpandoColumnModelImpl.FINDER_CACHE_ENABLED,
093 ExpandoColumnImpl.class, FINDER_CLASS_NAME_LIST_WITH_PAGINATION,
094 "findByTableId",
095 new String[] {
096 Long.class.getName(),
097
098 Integer.class.getName(), Integer.class.getName(),
099 OrderByComparator.class.getName()
100 });
101 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_TABLEID =
102 new FinderPath(ExpandoColumnModelImpl.ENTITY_CACHE_ENABLED,
103 ExpandoColumnModelImpl.FINDER_CACHE_ENABLED,
104 ExpandoColumnImpl.class, FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION,
105 "findByTableId", new String[] { Long.class.getName() },
106 ExpandoColumnModelImpl.TABLEID_COLUMN_BITMASK |
107 ExpandoColumnModelImpl.NAME_COLUMN_BITMASK);
108 public static final FinderPath FINDER_PATH_COUNT_BY_TABLEID = new FinderPath(ExpandoColumnModelImpl.ENTITY_CACHE_ENABLED,
109 ExpandoColumnModelImpl.FINDER_CACHE_ENABLED, Long.class,
110 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByTableId",
111 new String[] { Long.class.getName() });
112
113
120 @Override
121 public List<ExpandoColumn> findByTableId(long tableId)
122 throws SystemException {
123 return findByTableId(tableId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
124 }
125
126
139 @Override
140 public List<ExpandoColumn> findByTableId(long tableId, int start, int end)
141 throws SystemException {
142 return findByTableId(tableId, start, end, null);
143 }
144
145
159 @Override
160 public List<ExpandoColumn> findByTableId(long tableId, int start, int end,
161 OrderByComparator orderByComparator) throws SystemException {
162 boolean pagination = true;
163 FinderPath finderPath = null;
164 Object[] finderArgs = null;
165
166 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
167 (orderByComparator == null)) {
168 pagination = false;
169 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_TABLEID;
170 finderArgs = new Object[] { tableId };
171 }
172 else {
173 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_TABLEID;
174 finderArgs = new Object[] { tableId, start, end, orderByComparator };
175 }
176
177 List<ExpandoColumn> list = (List<ExpandoColumn>)FinderCacheUtil.getResult(finderPath,
178 finderArgs, this);
179
180 if ((list != null) && !list.isEmpty()) {
181 for (ExpandoColumn expandoColumn : list) {
182 if ((tableId != expandoColumn.getTableId())) {
183 list = null;
184
185 break;
186 }
187 }
188 }
189
190 if (list == null) {
191 StringBundler query = null;
192
193 if (orderByComparator != null) {
194 query = new StringBundler(3 +
195 (orderByComparator.getOrderByFields().length * 3));
196 }
197 else {
198 query = new StringBundler(3);
199 }
200
201 query.append(_SQL_SELECT_EXPANDOCOLUMN_WHERE);
202
203 query.append(_FINDER_COLUMN_TABLEID_TABLEID_2);
204
205 if (orderByComparator != null) {
206 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
207 orderByComparator);
208 }
209 else
210 if (pagination) {
211 query.append(ExpandoColumnModelImpl.ORDER_BY_JPQL);
212 }
213
214 String sql = query.toString();
215
216 Session session = null;
217
218 try {
219 session = openSession();
220
221 Query q = session.createQuery(sql);
222
223 QueryPos qPos = QueryPos.getInstance(q);
224
225 qPos.add(tableId);
226
227 if (!pagination) {
228 list = (List<ExpandoColumn>)QueryUtil.list(q, getDialect(),
229 start, end, false);
230
231 Collections.sort(list);
232
233 list = new UnmodifiableList<ExpandoColumn>(list);
234 }
235 else {
236 list = (List<ExpandoColumn>)QueryUtil.list(q, getDialect(),
237 start, end);
238 }
239
240 cacheResult(list);
241
242 FinderCacheUtil.putResult(finderPath, finderArgs, list);
243 }
244 catch (Exception e) {
245 FinderCacheUtil.removeResult(finderPath, finderArgs);
246
247 throw processException(e);
248 }
249 finally {
250 closeSession(session);
251 }
252 }
253
254 return list;
255 }
256
257
266 @Override
267 public ExpandoColumn findByTableId_First(long tableId,
268 OrderByComparator orderByComparator)
269 throws NoSuchColumnException, SystemException {
270 ExpandoColumn expandoColumn = fetchByTableId_First(tableId,
271 orderByComparator);
272
273 if (expandoColumn != null) {
274 return expandoColumn;
275 }
276
277 StringBundler msg = new StringBundler(4);
278
279 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
280
281 msg.append("tableId=");
282 msg.append(tableId);
283
284 msg.append(StringPool.CLOSE_CURLY_BRACE);
285
286 throw new NoSuchColumnException(msg.toString());
287 }
288
289
297 @Override
298 public ExpandoColumn fetchByTableId_First(long tableId,
299 OrderByComparator orderByComparator) throws SystemException {
300 List<ExpandoColumn> list = findByTableId(tableId, 0, 1,
301 orderByComparator);
302
303 if (!list.isEmpty()) {
304 return list.get(0);
305 }
306
307 return null;
308 }
309
310
319 @Override
320 public ExpandoColumn findByTableId_Last(long tableId,
321 OrderByComparator orderByComparator)
322 throws NoSuchColumnException, SystemException {
323 ExpandoColumn expandoColumn = fetchByTableId_Last(tableId,
324 orderByComparator);
325
326 if (expandoColumn != null) {
327 return expandoColumn;
328 }
329
330 StringBundler msg = new StringBundler(4);
331
332 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
333
334 msg.append("tableId=");
335 msg.append(tableId);
336
337 msg.append(StringPool.CLOSE_CURLY_BRACE);
338
339 throw new NoSuchColumnException(msg.toString());
340 }
341
342
350 @Override
351 public ExpandoColumn fetchByTableId_Last(long tableId,
352 OrderByComparator orderByComparator) throws SystemException {
353 int count = countByTableId(tableId);
354
355 if (count == 0) {
356 return null;
357 }
358
359 List<ExpandoColumn> list = findByTableId(tableId, count - 1, count,
360 orderByComparator);
361
362 if (!list.isEmpty()) {
363 return list.get(0);
364 }
365
366 return null;
367 }
368
369
379 @Override
380 public ExpandoColumn[] findByTableId_PrevAndNext(long columnId,
381 long tableId, OrderByComparator orderByComparator)
382 throws NoSuchColumnException, SystemException {
383 ExpandoColumn expandoColumn = findByPrimaryKey(columnId);
384
385 Session session = null;
386
387 try {
388 session = openSession();
389
390 ExpandoColumn[] array = new ExpandoColumnImpl[3];
391
392 array[0] = getByTableId_PrevAndNext(session, expandoColumn,
393 tableId, orderByComparator, true);
394
395 array[1] = expandoColumn;
396
397 array[2] = getByTableId_PrevAndNext(session, expandoColumn,
398 tableId, orderByComparator, false);
399
400 return array;
401 }
402 catch (Exception e) {
403 throw processException(e);
404 }
405 finally {
406 closeSession(session);
407 }
408 }
409
410 protected ExpandoColumn getByTableId_PrevAndNext(Session session,
411 ExpandoColumn expandoColumn, long tableId,
412 OrderByComparator orderByComparator, boolean previous) {
413 StringBundler query = null;
414
415 if (orderByComparator != null) {
416 query = new StringBundler(6 +
417 (orderByComparator.getOrderByFields().length * 6));
418 }
419 else {
420 query = new StringBundler(3);
421 }
422
423 query.append(_SQL_SELECT_EXPANDOCOLUMN_WHERE);
424
425 query.append(_FINDER_COLUMN_TABLEID_TABLEID_2);
426
427 if (orderByComparator != null) {
428 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
429
430 if (orderByConditionFields.length > 0) {
431 query.append(WHERE_AND);
432 }
433
434 for (int i = 0; i < orderByConditionFields.length; i++) {
435 query.append(_ORDER_BY_ENTITY_ALIAS);
436 query.append(orderByConditionFields[i]);
437
438 if ((i + 1) < orderByConditionFields.length) {
439 if (orderByComparator.isAscending() ^ previous) {
440 query.append(WHERE_GREATER_THAN_HAS_NEXT);
441 }
442 else {
443 query.append(WHERE_LESSER_THAN_HAS_NEXT);
444 }
445 }
446 else {
447 if (orderByComparator.isAscending() ^ previous) {
448 query.append(WHERE_GREATER_THAN);
449 }
450 else {
451 query.append(WHERE_LESSER_THAN);
452 }
453 }
454 }
455
456 query.append(ORDER_BY_CLAUSE);
457
458 String[] orderByFields = orderByComparator.getOrderByFields();
459
460 for (int i = 0; i < orderByFields.length; i++) {
461 query.append(_ORDER_BY_ENTITY_ALIAS);
462 query.append(orderByFields[i]);
463
464 if ((i + 1) < orderByFields.length) {
465 if (orderByComparator.isAscending() ^ previous) {
466 query.append(ORDER_BY_ASC_HAS_NEXT);
467 }
468 else {
469 query.append(ORDER_BY_DESC_HAS_NEXT);
470 }
471 }
472 else {
473 if (orderByComparator.isAscending() ^ previous) {
474 query.append(ORDER_BY_ASC);
475 }
476 else {
477 query.append(ORDER_BY_DESC);
478 }
479 }
480 }
481 }
482 else {
483 query.append(ExpandoColumnModelImpl.ORDER_BY_JPQL);
484 }
485
486 String sql = query.toString();
487
488 Query q = session.createQuery(sql);
489
490 q.setFirstResult(0);
491 q.setMaxResults(2);
492
493 QueryPos qPos = QueryPos.getInstance(q);
494
495 qPos.add(tableId);
496
497 if (orderByComparator != null) {
498 Object[] values = orderByComparator.getOrderByConditionValues(expandoColumn);
499
500 for (Object value : values) {
501 qPos.add(value);
502 }
503 }
504
505 List<ExpandoColumn> list = q.list();
506
507 if (list.size() == 2) {
508 return list.get(1);
509 }
510 else {
511 return null;
512 }
513 }
514
515
522 @Override
523 public List<ExpandoColumn> filterFindByTableId(long tableId)
524 throws SystemException {
525 return filterFindByTableId(tableId, QueryUtil.ALL_POS,
526 QueryUtil.ALL_POS, null);
527 }
528
529
542 @Override
543 public List<ExpandoColumn> filterFindByTableId(long tableId, int start,
544 int end) throws SystemException {
545 return filterFindByTableId(tableId, start, end, null);
546 }
547
548
562 @Override
563 public List<ExpandoColumn> filterFindByTableId(long tableId, int start,
564 int end, OrderByComparator orderByComparator) throws SystemException {
565 if (!InlineSQLHelperUtil.isEnabled()) {
566 return findByTableId(tableId, start, end, orderByComparator);
567 }
568
569 StringBundler query = null;
570
571 if (orderByComparator != null) {
572 query = new StringBundler(3 +
573 (orderByComparator.getOrderByFields().length * 3));
574 }
575 else {
576 query = new StringBundler(3);
577 }
578
579 if (getDB().isSupportsInlineDistinct()) {
580 query.append(_FILTER_SQL_SELECT_EXPANDOCOLUMN_WHERE);
581 }
582 else {
583 query.append(_FILTER_SQL_SELECT_EXPANDOCOLUMN_NO_INLINE_DISTINCT_WHERE_1);
584 }
585
586 query.append(_FINDER_COLUMN_TABLEID_TABLEID_2);
587
588 if (!getDB().isSupportsInlineDistinct()) {
589 query.append(_FILTER_SQL_SELECT_EXPANDOCOLUMN_NO_INLINE_DISTINCT_WHERE_2);
590 }
591
592 if (orderByComparator != null) {
593 if (getDB().isSupportsInlineDistinct()) {
594 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
595 orderByComparator, true);
596 }
597 else {
598 appendOrderByComparator(query, _ORDER_BY_ENTITY_TABLE,
599 orderByComparator, true);
600 }
601 }
602 else {
603 if (getDB().isSupportsInlineDistinct()) {
604 query.append(ExpandoColumnModelImpl.ORDER_BY_JPQL);
605 }
606 else {
607 query.append(ExpandoColumnModelImpl.ORDER_BY_SQL);
608 }
609 }
610
611 String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
612 ExpandoColumn.class.getName(),
613 _FILTER_ENTITY_TABLE_FILTER_PK_COLUMN);
614
615 Session session = null;
616
617 try {
618 session = openSession();
619
620 SQLQuery q = session.createSQLQuery(sql);
621
622 if (getDB().isSupportsInlineDistinct()) {
623 q.addEntity(_FILTER_ENTITY_ALIAS, ExpandoColumnImpl.class);
624 }
625 else {
626 q.addEntity(_FILTER_ENTITY_TABLE, ExpandoColumnImpl.class);
627 }
628
629 QueryPos qPos = QueryPos.getInstance(q);
630
631 qPos.add(tableId);
632
633 return (List<ExpandoColumn>)QueryUtil.list(q, getDialect(), start,
634 end);
635 }
636 catch (Exception e) {
637 throw processException(e);
638 }
639 finally {
640 closeSession(session);
641 }
642 }
643
644
654 @Override
655 public ExpandoColumn[] filterFindByTableId_PrevAndNext(long columnId,
656 long tableId, OrderByComparator orderByComparator)
657 throws NoSuchColumnException, SystemException {
658 if (!InlineSQLHelperUtil.isEnabled()) {
659 return findByTableId_PrevAndNext(columnId, tableId,
660 orderByComparator);
661 }
662
663 ExpandoColumn expandoColumn = findByPrimaryKey(columnId);
664
665 Session session = null;
666
667 try {
668 session = openSession();
669
670 ExpandoColumn[] array = new ExpandoColumnImpl[3];
671
672 array[0] = filterGetByTableId_PrevAndNext(session, expandoColumn,
673 tableId, orderByComparator, true);
674
675 array[1] = expandoColumn;
676
677 array[2] = filterGetByTableId_PrevAndNext(session, expandoColumn,
678 tableId, orderByComparator, false);
679
680 return array;
681 }
682 catch (Exception e) {
683 throw processException(e);
684 }
685 finally {
686 closeSession(session);
687 }
688 }
689
690 protected ExpandoColumn filterGetByTableId_PrevAndNext(Session session,
691 ExpandoColumn expandoColumn, long tableId,
692 OrderByComparator orderByComparator, boolean previous) {
693 StringBundler query = null;
694
695 if (orderByComparator != null) {
696 query = new StringBundler(6 +
697 (orderByComparator.getOrderByFields().length * 6));
698 }
699 else {
700 query = new StringBundler(3);
701 }
702
703 if (getDB().isSupportsInlineDistinct()) {
704 query.append(_FILTER_SQL_SELECT_EXPANDOCOLUMN_WHERE);
705 }
706 else {
707 query.append(_FILTER_SQL_SELECT_EXPANDOCOLUMN_NO_INLINE_DISTINCT_WHERE_1);
708 }
709
710 query.append(_FINDER_COLUMN_TABLEID_TABLEID_2);
711
712 if (!getDB().isSupportsInlineDistinct()) {
713 query.append(_FILTER_SQL_SELECT_EXPANDOCOLUMN_NO_INLINE_DISTINCT_WHERE_2);
714 }
715
716 if (orderByComparator != null) {
717 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
718
719 if (orderByConditionFields.length > 0) {
720 query.append(WHERE_AND);
721 }
722
723 for (int i = 0; i < orderByConditionFields.length; i++) {
724 if (getDB().isSupportsInlineDistinct()) {
725 query.append(_ORDER_BY_ENTITY_ALIAS);
726 }
727 else {
728 query.append(_ORDER_BY_ENTITY_TABLE);
729 }
730
731 query.append(orderByConditionFields[i]);
732
733 if ((i + 1) < orderByConditionFields.length) {
734 if (orderByComparator.isAscending() ^ previous) {
735 query.append(WHERE_GREATER_THAN_HAS_NEXT);
736 }
737 else {
738 query.append(WHERE_LESSER_THAN_HAS_NEXT);
739 }
740 }
741 else {
742 if (orderByComparator.isAscending() ^ previous) {
743 query.append(WHERE_GREATER_THAN);
744 }
745 else {
746 query.append(WHERE_LESSER_THAN);
747 }
748 }
749 }
750
751 query.append(ORDER_BY_CLAUSE);
752
753 String[] orderByFields = orderByComparator.getOrderByFields();
754
755 for (int i = 0; i < orderByFields.length; i++) {
756 if (getDB().isSupportsInlineDistinct()) {
757 query.append(_ORDER_BY_ENTITY_ALIAS);
758 }
759 else {
760 query.append(_ORDER_BY_ENTITY_TABLE);
761 }
762
763 query.append(orderByFields[i]);
764
765 if ((i + 1) < orderByFields.length) {
766 if (orderByComparator.isAscending() ^ previous) {
767 query.append(ORDER_BY_ASC_HAS_NEXT);
768 }
769 else {
770 query.append(ORDER_BY_DESC_HAS_NEXT);
771 }
772 }
773 else {
774 if (orderByComparator.isAscending() ^ previous) {
775 query.append(ORDER_BY_ASC);
776 }
777 else {
778 query.append(ORDER_BY_DESC);
779 }
780 }
781 }
782 }
783 else {
784 if (getDB().isSupportsInlineDistinct()) {
785 query.append(ExpandoColumnModelImpl.ORDER_BY_JPQL);
786 }
787 else {
788 query.append(ExpandoColumnModelImpl.ORDER_BY_SQL);
789 }
790 }
791
792 String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
793 ExpandoColumn.class.getName(),
794 _FILTER_ENTITY_TABLE_FILTER_PK_COLUMN);
795
796 SQLQuery q = session.createSQLQuery(sql);
797
798 q.setFirstResult(0);
799 q.setMaxResults(2);
800
801 if (getDB().isSupportsInlineDistinct()) {
802 q.addEntity(_FILTER_ENTITY_ALIAS, ExpandoColumnImpl.class);
803 }
804 else {
805 q.addEntity(_FILTER_ENTITY_TABLE, ExpandoColumnImpl.class);
806 }
807
808 QueryPos qPos = QueryPos.getInstance(q);
809
810 qPos.add(tableId);
811
812 if (orderByComparator != null) {
813 Object[] values = orderByComparator.getOrderByConditionValues(expandoColumn);
814
815 for (Object value : values) {
816 qPos.add(value);
817 }
818 }
819
820 List<ExpandoColumn> list = q.list();
821
822 if (list.size() == 2) {
823 return list.get(1);
824 }
825 else {
826 return null;
827 }
828 }
829
830
836 @Override
837 public void removeByTableId(long tableId) throws SystemException {
838 for (ExpandoColumn expandoColumn : findByTableId(tableId,
839 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
840 remove(expandoColumn);
841 }
842 }
843
844
851 @Override
852 public int countByTableId(long tableId) throws SystemException {
853 FinderPath finderPath = FINDER_PATH_COUNT_BY_TABLEID;
854
855 Object[] finderArgs = new Object[] { tableId };
856
857 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
858 this);
859
860 if (count == null) {
861 StringBundler query = new StringBundler(2);
862
863 query.append(_SQL_COUNT_EXPANDOCOLUMN_WHERE);
864
865 query.append(_FINDER_COLUMN_TABLEID_TABLEID_2);
866
867 String sql = query.toString();
868
869 Session session = null;
870
871 try {
872 session = openSession();
873
874 Query q = session.createQuery(sql);
875
876 QueryPos qPos = QueryPos.getInstance(q);
877
878 qPos.add(tableId);
879
880 count = (Long)q.uniqueResult();
881
882 FinderCacheUtil.putResult(finderPath, finderArgs, count);
883 }
884 catch (Exception e) {
885 FinderCacheUtil.removeResult(finderPath, finderArgs);
886
887 throw processException(e);
888 }
889 finally {
890 closeSession(session);
891 }
892 }
893
894 return count.intValue();
895 }
896
897
904 @Override
905 public int filterCountByTableId(long tableId) throws SystemException {
906 if (!InlineSQLHelperUtil.isEnabled()) {
907 return countByTableId(tableId);
908 }
909
910 StringBundler query = new StringBundler(2);
911
912 query.append(_FILTER_SQL_COUNT_EXPANDOCOLUMN_WHERE);
913
914 query.append(_FINDER_COLUMN_TABLEID_TABLEID_2);
915
916 String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
917 ExpandoColumn.class.getName(),
918 _FILTER_ENTITY_TABLE_FILTER_PK_COLUMN);
919
920 Session session = null;
921
922 try {
923 session = openSession();
924
925 SQLQuery q = session.createSQLQuery(sql);
926
927 q.addScalar(COUNT_COLUMN_NAME,
928 com.liferay.portal.kernel.dao.orm.Type.LONG);
929
930 QueryPos qPos = QueryPos.getInstance(q);
931
932 qPos.add(tableId);
933
934 Long count = (Long)q.uniqueResult();
935
936 return count.intValue();
937 }
938 catch (Exception e) {
939 throw processException(e);
940 }
941 finally {
942 closeSession(session);
943 }
944 }
945
946 private static final String _FINDER_COLUMN_TABLEID_TABLEID_2 = "expandoColumn.tableId = ?";
947 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_T_N = new FinderPath(ExpandoColumnModelImpl.ENTITY_CACHE_ENABLED,
948 ExpandoColumnModelImpl.FINDER_CACHE_ENABLED,
949 ExpandoColumnImpl.class, FINDER_CLASS_NAME_LIST_WITH_PAGINATION,
950 "findByT_N",
951 new String[] {
952 Long.class.getName(), String.class.getName(),
953
954 Integer.class.getName(), Integer.class.getName(),
955 OrderByComparator.class.getName()
956 });
957 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_T_N = new FinderPath(ExpandoColumnModelImpl.ENTITY_CACHE_ENABLED,
958 ExpandoColumnModelImpl.FINDER_CACHE_ENABLED,
959 ExpandoColumnImpl.class, FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION,
960 "findByT_N",
961 new String[] { Long.class.getName(), String.class.getName() },
962 ExpandoColumnModelImpl.TABLEID_COLUMN_BITMASK |
963 ExpandoColumnModelImpl.NAME_COLUMN_BITMASK);
964 public static final FinderPath FINDER_PATH_FETCH_BY_T_N = new FinderPath(ExpandoColumnModelImpl.ENTITY_CACHE_ENABLED,
965 ExpandoColumnModelImpl.FINDER_CACHE_ENABLED,
966 ExpandoColumnImpl.class, FINDER_CLASS_NAME_ENTITY, "fetchByT_N",
967 new String[] { Long.class.getName(), String.class.getName() },
968 ExpandoColumnModelImpl.TABLEID_COLUMN_BITMASK |
969 ExpandoColumnModelImpl.NAME_COLUMN_BITMASK);
970 public static final FinderPath FINDER_PATH_COUNT_BY_T_N = new FinderPath(ExpandoColumnModelImpl.ENTITY_CACHE_ENABLED,
971 ExpandoColumnModelImpl.FINDER_CACHE_ENABLED, Long.class,
972 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByT_N",
973 new String[] { Long.class.getName(), String.class.getName() });
974 public static final FinderPath FINDER_PATH_WITH_PAGINATION_COUNT_BY_T_N = new FinderPath(ExpandoColumnModelImpl.ENTITY_CACHE_ENABLED,
975 ExpandoColumnModelImpl.FINDER_CACHE_ENABLED, Long.class,
976 FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "countByT_N",
977 new String[] { Long.class.getName(), String.class.getName() });
978
979
991 @Override
992 public List<ExpandoColumn> findByT_N(long tableId, String[] names)
993 throws SystemException {
994 return findByT_N(tableId, names, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
995 null);
996 }
997
998
1012 @Override
1013 public List<ExpandoColumn> findByT_N(long tableId, String[] names,
1014 int start, int end) throws SystemException {
1015 return findByT_N(tableId, names, start, end, null);
1016 }
1017
1018
1033 @Override
1034 public List<ExpandoColumn> findByT_N(long tableId, String[] names,
1035 int start, int end, OrderByComparator orderByComparator)
1036 throws SystemException {
1037 if ((names != null) && (names.length == 1)) {
1038 ExpandoColumn expandoColumn = fetchByT_N(tableId, names[0]);
1039
1040 if (expandoColumn == null) {
1041 return Collections.emptyList();
1042 }
1043 else {
1044 List<ExpandoColumn> list = new ArrayList<ExpandoColumn>(1);
1045
1046 list.add(expandoColumn);
1047
1048 return list;
1049 }
1050 }
1051
1052 boolean pagination = true;
1053 Object[] finderArgs = null;
1054
1055 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
1056 (orderByComparator == null)) {
1057 pagination = false;
1058 finderArgs = new Object[] { tableId, StringUtil.merge(names) };
1059 }
1060 else {
1061 finderArgs = new Object[] {
1062 tableId, StringUtil.merge(names),
1063
1064 start, end, orderByComparator
1065 };
1066 }
1067
1068 List<ExpandoColumn> list = (List<ExpandoColumn>)FinderCacheUtil.getResult(FINDER_PATH_WITH_PAGINATION_FIND_BY_T_N,
1069 finderArgs, this);
1070
1071 if ((list != null) && !list.isEmpty()) {
1072 for (ExpandoColumn expandoColumn : list) {
1073 if ((tableId != expandoColumn.getTableId()) ||
1074 !ArrayUtil.contains(names, expandoColumn.getName())) {
1075 list = null;
1076
1077 break;
1078 }
1079 }
1080 }
1081
1082 if (list == null) {
1083 StringBundler query = new StringBundler();
1084
1085 query.append(_SQL_SELECT_EXPANDOCOLUMN_WHERE);
1086
1087 boolean conjunctionable = false;
1088
1089 if (conjunctionable) {
1090 query.append(WHERE_AND);
1091 }
1092
1093 query.append(_FINDER_COLUMN_T_N_TABLEID_5);
1094
1095 conjunctionable = true;
1096
1097 if ((names == null) || (names.length > 0)) {
1098 if (conjunctionable) {
1099 query.append(WHERE_AND);
1100 }
1101
1102 query.append(StringPool.OPEN_PARENTHESIS);
1103
1104 for (int i = 0; i < names.length; i++) {
1105 String name = names[i];
1106
1107 if (name == null) {
1108 query.append(_FINDER_COLUMN_T_N_NAME_4);
1109 }
1110 else if (name.equals(StringPool.BLANK)) {
1111 query.append(_FINDER_COLUMN_T_N_NAME_6);
1112 }
1113 else {
1114 query.append(_FINDER_COLUMN_T_N_NAME_5);
1115 }
1116
1117 if ((i + 1) < names.length) {
1118 query.append(WHERE_OR);
1119 }
1120 }
1121
1122 query.append(StringPool.CLOSE_PARENTHESIS);
1123
1124 conjunctionable = true;
1125 }
1126
1127 if (orderByComparator != null) {
1128 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1129 orderByComparator);
1130 }
1131 else
1132 if (pagination) {
1133 query.append(ExpandoColumnModelImpl.ORDER_BY_JPQL);
1134 }
1135
1136 String sql = query.toString();
1137
1138 Session session = null;
1139
1140 try {
1141 session = openSession();
1142
1143 Query q = session.createQuery(sql);
1144
1145 QueryPos qPos = QueryPos.getInstance(q);
1146
1147 qPos.add(tableId);
1148
1149 if (names != null) {
1150 qPos.add(names);
1151 }
1152
1153 if (!pagination) {
1154 list = (List<ExpandoColumn>)QueryUtil.list(q, getDialect(),
1155 start, end, false);
1156
1157 Collections.sort(list);
1158
1159 list = new UnmodifiableList<ExpandoColumn>(list);
1160 }
1161 else {
1162 list = (List<ExpandoColumn>)QueryUtil.list(q, getDialect(),
1163 start, end);
1164 }
1165
1166 cacheResult(list);
1167
1168 FinderCacheUtil.putResult(FINDER_PATH_WITH_PAGINATION_FIND_BY_T_N,
1169 finderArgs, list);
1170 }
1171 catch (Exception e) {
1172 FinderCacheUtil.removeResult(FINDER_PATH_WITH_PAGINATION_FIND_BY_T_N,
1173 finderArgs);
1174
1175 throw processException(e);
1176 }
1177 finally {
1178 closeSession(session);
1179 }
1180 }
1181
1182 return list;
1183 }
1184
1185
1194 @Override
1195 public ExpandoColumn findByT_N(long tableId, String name)
1196 throws NoSuchColumnException, SystemException {
1197 ExpandoColumn expandoColumn = fetchByT_N(tableId, name);
1198
1199 if (expandoColumn == null) {
1200 StringBundler msg = new StringBundler(6);
1201
1202 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1203
1204 msg.append("tableId=");
1205 msg.append(tableId);
1206
1207 msg.append(", name=");
1208 msg.append(name);
1209
1210 msg.append(StringPool.CLOSE_CURLY_BRACE);
1211
1212 if (_log.isWarnEnabled()) {
1213 _log.warn(msg.toString());
1214 }
1215
1216 throw new NoSuchColumnException(msg.toString());
1217 }
1218
1219 return expandoColumn;
1220 }
1221
1222
1230 @Override
1231 public ExpandoColumn fetchByT_N(long tableId, String name)
1232 throws SystemException {
1233 return fetchByT_N(tableId, name, true);
1234 }
1235
1236
1245 @Override
1246 public ExpandoColumn fetchByT_N(long tableId, String name,
1247 boolean retrieveFromCache) throws SystemException {
1248 Object[] finderArgs = new Object[] { tableId, name };
1249
1250 Object result = null;
1251
1252 if (retrieveFromCache) {
1253 result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_T_N,
1254 finderArgs, this);
1255 }
1256
1257 if (result instanceof ExpandoColumn) {
1258 ExpandoColumn expandoColumn = (ExpandoColumn)result;
1259
1260 if ((tableId != expandoColumn.getTableId()) ||
1261 !Validator.equals(name, expandoColumn.getName())) {
1262 result = null;
1263 }
1264 }
1265
1266 if (result == null) {
1267 StringBundler query = new StringBundler(4);
1268
1269 query.append(_SQL_SELECT_EXPANDOCOLUMN_WHERE);
1270
1271 query.append(_FINDER_COLUMN_T_N_TABLEID_2);
1272
1273 boolean bindName = false;
1274
1275 if (name == null) {
1276 query.append(_FINDER_COLUMN_T_N_NAME_1);
1277 }
1278 else if (name.equals(StringPool.BLANK)) {
1279 query.append(_FINDER_COLUMN_T_N_NAME_3);
1280 }
1281 else {
1282 bindName = true;
1283
1284 query.append(_FINDER_COLUMN_T_N_NAME_2);
1285 }
1286
1287 String sql = query.toString();
1288
1289 Session session = null;
1290
1291 try {
1292 session = openSession();
1293
1294 Query q = session.createQuery(sql);
1295
1296 QueryPos qPos = QueryPos.getInstance(q);
1297
1298 qPos.add(tableId);
1299
1300 if (bindName) {
1301 qPos.add(name);
1302 }
1303
1304 List<ExpandoColumn> list = q.list();
1305
1306 if (list.isEmpty()) {
1307 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_T_N,
1308 finderArgs, list);
1309 }
1310 else {
1311 ExpandoColumn expandoColumn = list.get(0);
1312
1313 result = expandoColumn;
1314
1315 cacheResult(expandoColumn);
1316
1317 if ((expandoColumn.getTableId() != tableId) ||
1318 (expandoColumn.getName() == null) ||
1319 !expandoColumn.getName().equals(name)) {
1320 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_T_N,
1321 finderArgs, expandoColumn);
1322 }
1323 }
1324 }
1325 catch (Exception e) {
1326 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_T_N,
1327 finderArgs);
1328
1329 throw processException(e);
1330 }
1331 finally {
1332 closeSession(session);
1333 }
1334 }
1335
1336 if (result instanceof List<?>) {
1337 return null;
1338 }
1339 else {
1340 return (ExpandoColumn)result;
1341 }
1342 }
1343
1344
1352 @Override
1353 public ExpandoColumn removeByT_N(long tableId, String name)
1354 throws NoSuchColumnException, SystemException {
1355 ExpandoColumn expandoColumn = findByT_N(tableId, name);
1356
1357 return remove(expandoColumn);
1358 }
1359
1360
1368 @Override
1369 public int countByT_N(long tableId, String name) throws SystemException {
1370 FinderPath finderPath = FINDER_PATH_COUNT_BY_T_N;
1371
1372 Object[] finderArgs = new Object[] { tableId, name };
1373
1374 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
1375 this);
1376
1377 if (count == null) {
1378 StringBundler query = new StringBundler(3);
1379
1380 query.append(_SQL_COUNT_EXPANDOCOLUMN_WHERE);
1381
1382 query.append(_FINDER_COLUMN_T_N_TABLEID_2);
1383
1384 boolean bindName = false;
1385
1386 if (name == null) {
1387 query.append(_FINDER_COLUMN_T_N_NAME_1);
1388 }
1389 else if (name.equals(StringPool.BLANK)) {
1390 query.append(_FINDER_COLUMN_T_N_NAME_3);
1391 }
1392 else {
1393 bindName = true;
1394
1395 query.append(_FINDER_COLUMN_T_N_NAME_2);
1396 }
1397
1398 String sql = query.toString();
1399
1400 Session session = null;
1401
1402 try {
1403 session = openSession();
1404
1405 Query q = session.createQuery(sql);
1406
1407 QueryPos qPos = QueryPos.getInstance(q);
1408
1409 qPos.add(tableId);
1410
1411 if (bindName) {
1412 qPos.add(name);
1413 }
1414
1415 count = (Long)q.uniqueResult();
1416
1417 FinderCacheUtil.putResult(finderPath, finderArgs, count);
1418 }
1419 catch (Exception e) {
1420 FinderCacheUtil.removeResult(finderPath, finderArgs);
1421
1422 throw processException(e);
1423 }
1424 finally {
1425 closeSession(session);
1426 }
1427 }
1428
1429 return count.intValue();
1430 }
1431
1432
1440 @Override
1441 public int countByT_N(long tableId, String[] names)
1442 throws SystemException {
1443 Object[] finderArgs = new Object[] { tableId, StringUtil.merge(names) };
1444
1445 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_WITH_PAGINATION_COUNT_BY_T_N,
1446 finderArgs, this);
1447
1448 if (count == null) {
1449 StringBundler query = new StringBundler();
1450
1451 query.append(_SQL_COUNT_EXPANDOCOLUMN_WHERE);
1452
1453 boolean conjunctionable = false;
1454
1455 if (conjunctionable) {
1456 query.append(WHERE_AND);
1457 }
1458
1459 query.append(_FINDER_COLUMN_T_N_TABLEID_5);
1460
1461 conjunctionable = true;
1462
1463 if ((names == null) || (names.length > 0)) {
1464 if (conjunctionable) {
1465 query.append(WHERE_AND);
1466 }
1467
1468 query.append(StringPool.OPEN_PARENTHESIS);
1469
1470 for (int i = 0; i < names.length; i++) {
1471 String name = names[i];
1472
1473 if (name == null) {
1474 query.append(_FINDER_COLUMN_T_N_NAME_4);
1475 }
1476 else if (name.equals(StringPool.BLANK)) {
1477 query.append(_FINDER_COLUMN_T_N_NAME_6);
1478 }
1479 else {
1480 query.append(_FINDER_COLUMN_T_N_NAME_5);
1481 }
1482
1483 if ((i + 1) < names.length) {
1484 query.append(WHERE_OR);
1485 }
1486 }
1487
1488 query.append(StringPool.CLOSE_PARENTHESIS);
1489
1490 conjunctionable = true;
1491 }
1492
1493 String sql = query.toString();
1494
1495 Session session = null;
1496
1497 try {
1498 session = openSession();
1499
1500 Query q = session.createQuery(sql);
1501
1502 QueryPos qPos = QueryPos.getInstance(q);
1503
1504 qPos.add(tableId);
1505
1506 if (names != null) {
1507 qPos.add(names);
1508 }
1509
1510 count = (Long)q.uniqueResult();
1511
1512 FinderCacheUtil.putResult(FINDER_PATH_WITH_PAGINATION_COUNT_BY_T_N,
1513 finderArgs, count);
1514 }
1515 catch (Exception e) {
1516 FinderCacheUtil.removeResult(FINDER_PATH_WITH_PAGINATION_COUNT_BY_T_N,
1517 finderArgs);
1518
1519 throw processException(e);
1520 }
1521 finally {
1522 closeSession(session);
1523 }
1524 }
1525
1526 return count.intValue();
1527 }
1528
1529
1537 @Override
1538 public int filterCountByT_N(long tableId, String name)
1539 throws SystemException {
1540 if (!InlineSQLHelperUtil.isEnabled()) {
1541 return countByT_N(tableId, name);
1542 }
1543
1544 StringBundler query = new StringBundler(3);
1545
1546 query.append(_FILTER_SQL_COUNT_EXPANDOCOLUMN_WHERE);
1547
1548 query.append(_FINDER_COLUMN_T_N_TABLEID_2);
1549
1550 boolean bindName = false;
1551
1552 if (name == null) {
1553 query.append(_FINDER_COLUMN_T_N_NAME_1);
1554 }
1555 else if (name.equals(StringPool.BLANK)) {
1556 query.append(_FINDER_COLUMN_T_N_NAME_3);
1557 }
1558 else {
1559 bindName = true;
1560
1561 query.append(_FINDER_COLUMN_T_N_NAME_2);
1562 }
1563
1564 String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
1565 ExpandoColumn.class.getName(),
1566 _FILTER_ENTITY_TABLE_FILTER_PK_COLUMN);
1567
1568 Session session = null;
1569
1570 try {
1571 session = openSession();
1572
1573 SQLQuery q = session.createSQLQuery(sql);
1574
1575 q.addScalar(COUNT_COLUMN_NAME,
1576 com.liferay.portal.kernel.dao.orm.Type.LONG);
1577
1578 QueryPos qPos = QueryPos.getInstance(q);
1579
1580 qPos.add(tableId);
1581
1582 if (bindName) {
1583 qPos.add(name);
1584 }
1585
1586 Long count = (Long)q.uniqueResult();
1587
1588 return count.intValue();
1589 }
1590 catch (Exception e) {
1591 throw processException(e);
1592 }
1593 finally {
1594 closeSession(session);
1595 }
1596 }
1597
1598
1606 @Override
1607 public int filterCountByT_N(long tableId, String[] names)
1608 throws SystemException {
1609 if (!InlineSQLHelperUtil.isEnabled()) {
1610 return countByT_N(tableId, names);
1611 }
1612
1613 StringBundler query = new StringBundler();
1614
1615 query.append(_FILTER_SQL_COUNT_EXPANDOCOLUMN_WHERE);
1616
1617 boolean conjunctionable = false;
1618
1619 if (conjunctionable) {
1620 query.append(WHERE_AND);
1621 }
1622
1623 query.append(_FINDER_COLUMN_T_N_TABLEID_5);
1624
1625 conjunctionable = true;
1626
1627 if ((names == null) || (names.length > 0)) {
1628 if (conjunctionable) {
1629 query.append(WHERE_AND);
1630 }
1631
1632 query.append(StringPool.OPEN_PARENTHESIS);
1633
1634 for (int i = 0; i < names.length; i++) {
1635 String name = names[i];
1636
1637 if (name == null) {
1638 query.append(_FINDER_COLUMN_T_N_NAME_4);
1639 }
1640 else if (name.equals(StringPool.BLANK)) {
1641 query.append(_FINDER_COLUMN_T_N_NAME_6);
1642 }
1643 else {
1644 query.append(_FINDER_COLUMN_T_N_NAME_5);
1645 }
1646
1647 if ((i + 1) < names.length) {
1648 query.append(WHERE_OR);
1649 }
1650 }
1651
1652 query.append(StringPool.CLOSE_PARENTHESIS);
1653
1654 conjunctionable = true;
1655 }
1656
1657 String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
1658 ExpandoColumn.class.getName(),
1659 _FILTER_ENTITY_TABLE_FILTER_PK_COLUMN);
1660
1661 Session session = null;
1662
1663 try {
1664 session = openSession();
1665
1666 SQLQuery q = session.createSQLQuery(sql);
1667
1668 q.addScalar(COUNT_COLUMN_NAME,
1669 com.liferay.portal.kernel.dao.orm.Type.LONG);
1670
1671 QueryPos qPos = QueryPos.getInstance(q);
1672
1673 qPos.add(tableId);
1674
1675 if (names != null) {
1676 qPos.add(names);
1677 }
1678
1679 Long count = (Long)q.uniqueResult();
1680
1681 return count.intValue();
1682 }
1683 catch (Exception e) {
1684 throw processException(e);
1685 }
1686 finally {
1687 closeSession(session);
1688 }
1689 }
1690
1691 private static final String _FINDER_COLUMN_T_N_TABLEID_2 = "expandoColumn.tableId = ? AND ";
1692 private static final String _FINDER_COLUMN_T_N_TABLEID_5 = "(" +
1693 removeConjunction(_FINDER_COLUMN_T_N_TABLEID_2) + ")";
1694 private static final String _FINDER_COLUMN_T_N_NAME_1 = "expandoColumn.name IS NULL";
1695 private static final String _FINDER_COLUMN_T_N_NAME_2 = "expandoColumn.name = ?";
1696 private static final String _FINDER_COLUMN_T_N_NAME_3 = "(expandoColumn.name IS NULL OR expandoColumn.name = '')";
1697 private static final String _FINDER_COLUMN_T_N_NAME_4 = "(" +
1698 removeConjunction(_FINDER_COLUMN_T_N_NAME_1) + ")";
1699 private static final String _FINDER_COLUMN_T_N_NAME_5 = "(" +
1700 removeConjunction(_FINDER_COLUMN_T_N_NAME_2) + ")";
1701 private static final String _FINDER_COLUMN_T_N_NAME_6 = "(" +
1702 removeConjunction(_FINDER_COLUMN_T_N_NAME_3) + ")";
1703
1704
1709 @Override
1710 public void cacheResult(ExpandoColumn expandoColumn) {
1711 EntityCacheUtil.putResult(ExpandoColumnModelImpl.ENTITY_CACHE_ENABLED,
1712 ExpandoColumnImpl.class, expandoColumn.getPrimaryKey(),
1713 expandoColumn);
1714
1715 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_T_N,
1716 new Object[] { expandoColumn.getTableId(), expandoColumn.getName() },
1717 expandoColumn);
1718
1719 expandoColumn.resetOriginalValues();
1720 }
1721
1722
1727 @Override
1728 public void cacheResult(List<ExpandoColumn> expandoColumns) {
1729 for (ExpandoColumn expandoColumn : expandoColumns) {
1730 if (EntityCacheUtil.getResult(
1731 ExpandoColumnModelImpl.ENTITY_CACHE_ENABLED,
1732 ExpandoColumnImpl.class, expandoColumn.getPrimaryKey()) == null) {
1733 cacheResult(expandoColumn);
1734 }
1735 else {
1736 expandoColumn.resetOriginalValues();
1737 }
1738 }
1739 }
1740
1741
1748 @Override
1749 public void clearCache() {
1750 if (_HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE) {
1751 CacheRegistryUtil.clear(ExpandoColumnImpl.class.getName());
1752 }
1753
1754 EntityCacheUtil.clearCache(ExpandoColumnImpl.class.getName());
1755
1756 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
1757 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
1758 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
1759 }
1760
1761
1768 @Override
1769 public void clearCache(ExpandoColumn expandoColumn) {
1770 EntityCacheUtil.removeResult(ExpandoColumnModelImpl.ENTITY_CACHE_ENABLED,
1771 ExpandoColumnImpl.class, expandoColumn.getPrimaryKey());
1772
1773 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
1774 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
1775
1776 clearUniqueFindersCache(expandoColumn);
1777 }
1778
1779 @Override
1780 public void clearCache(List<ExpandoColumn> expandoColumns) {
1781 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
1782 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
1783
1784 for (ExpandoColumn expandoColumn : expandoColumns) {
1785 EntityCacheUtil.removeResult(ExpandoColumnModelImpl.ENTITY_CACHE_ENABLED,
1786 ExpandoColumnImpl.class, expandoColumn.getPrimaryKey());
1787
1788 clearUniqueFindersCache(expandoColumn);
1789 }
1790 }
1791
1792 protected void cacheUniqueFindersCache(ExpandoColumn expandoColumn) {
1793 if (expandoColumn.isNew()) {
1794 Object[] args = new Object[] {
1795 expandoColumn.getTableId(), expandoColumn.getName()
1796 };
1797
1798 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_T_N, args,
1799 Long.valueOf(1));
1800 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_T_N, args,
1801 expandoColumn);
1802 }
1803 else {
1804 ExpandoColumnModelImpl expandoColumnModelImpl = (ExpandoColumnModelImpl)expandoColumn;
1805
1806 if ((expandoColumnModelImpl.getColumnBitmask() &
1807 FINDER_PATH_FETCH_BY_T_N.getColumnBitmask()) != 0) {
1808 Object[] args = new Object[] {
1809 expandoColumn.getTableId(), expandoColumn.getName()
1810 };
1811
1812 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_T_N, args,
1813 Long.valueOf(1));
1814 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_T_N, args,
1815 expandoColumn);
1816 }
1817 }
1818 }
1819
1820 protected void clearUniqueFindersCache(ExpandoColumn expandoColumn) {
1821 ExpandoColumnModelImpl expandoColumnModelImpl = (ExpandoColumnModelImpl)expandoColumn;
1822
1823 Object[] args = new Object[] {
1824 expandoColumn.getTableId(), expandoColumn.getName()
1825 };
1826
1827 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_T_N, args);
1828 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_T_N, args);
1829
1830 if ((expandoColumnModelImpl.getColumnBitmask() &
1831 FINDER_PATH_FETCH_BY_T_N.getColumnBitmask()) != 0) {
1832 args = new Object[] {
1833 expandoColumnModelImpl.getOriginalTableId(),
1834 expandoColumnModelImpl.getOriginalName()
1835 };
1836
1837 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_T_N, args);
1838 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_T_N, args);
1839 }
1840 }
1841
1842
1848 @Override
1849 public ExpandoColumn create(long columnId) {
1850 ExpandoColumn expandoColumn = new ExpandoColumnImpl();
1851
1852 expandoColumn.setNew(true);
1853 expandoColumn.setPrimaryKey(columnId);
1854
1855 return expandoColumn;
1856 }
1857
1858
1866 @Override
1867 public ExpandoColumn remove(long columnId)
1868 throws NoSuchColumnException, SystemException {
1869 return remove((Serializable)columnId);
1870 }
1871
1872
1880 @Override
1881 public ExpandoColumn remove(Serializable primaryKey)
1882 throws NoSuchColumnException, SystemException {
1883 Session session = null;
1884
1885 try {
1886 session = openSession();
1887
1888 ExpandoColumn expandoColumn = (ExpandoColumn)session.get(ExpandoColumnImpl.class,
1889 primaryKey);
1890
1891 if (expandoColumn == null) {
1892 if (_log.isWarnEnabled()) {
1893 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey);
1894 }
1895
1896 throw new NoSuchColumnException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
1897 primaryKey);
1898 }
1899
1900 return remove(expandoColumn);
1901 }
1902 catch (NoSuchColumnException nsee) {
1903 throw nsee;
1904 }
1905 catch (Exception e) {
1906 throw processException(e);
1907 }
1908 finally {
1909 closeSession(session);
1910 }
1911 }
1912
1913 @Override
1914 protected ExpandoColumn removeImpl(ExpandoColumn expandoColumn)
1915 throws SystemException {
1916 expandoColumn = toUnwrappedModel(expandoColumn);
1917
1918 Session session = null;
1919
1920 try {
1921 session = openSession();
1922
1923 if (!session.contains(expandoColumn)) {
1924 expandoColumn = (ExpandoColumn)session.get(ExpandoColumnImpl.class,
1925 expandoColumn.getPrimaryKeyObj());
1926 }
1927
1928 if (expandoColumn != null) {
1929 session.delete(expandoColumn);
1930 }
1931 }
1932 catch (Exception e) {
1933 throw processException(e);
1934 }
1935 finally {
1936 closeSession(session);
1937 }
1938
1939 if (expandoColumn != null) {
1940 clearCache(expandoColumn);
1941 }
1942
1943 return expandoColumn;
1944 }
1945
1946 @Override
1947 public ExpandoColumn updateImpl(
1948 com.liferay.portlet.expando.model.ExpandoColumn expandoColumn)
1949 throws SystemException {
1950 expandoColumn = toUnwrappedModel(expandoColumn);
1951
1952 boolean isNew = expandoColumn.isNew();
1953
1954 ExpandoColumnModelImpl expandoColumnModelImpl = (ExpandoColumnModelImpl)expandoColumn;
1955
1956 Session session = null;
1957
1958 try {
1959 session = openSession();
1960
1961 if (expandoColumn.isNew()) {
1962 session.save(expandoColumn);
1963
1964 expandoColumn.setNew(false);
1965 }
1966 else {
1967 session.merge(expandoColumn);
1968 }
1969 }
1970 catch (Exception e) {
1971 throw processException(e);
1972 }
1973 finally {
1974 closeSession(session);
1975 }
1976
1977 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
1978
1979 if (isNew || !ExpandoColumnModelImpl.COLUMN_BITMASK_ENABLED) {
1980 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
1981 }
1982
1983 else {
1984 if ((expandoColumnModelImpl.getColumnBitmask() &
1985 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_TABLEID.getColumnBitmask()) != 0) {
1986 Object[] args = new Object[] {
1987 expandoColumnModelImpl.getOriginalTableId()
1988 };
1989
1990 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_TABLEID, args);
1991 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_TABLEID,
1992 args);
1993
1994 args = new Object[] { expandoColumnModelImpl.getTableId() };
1995
1996 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_TABLEID, args);
1997 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_TABLEID,
1998 args);
1999 }
2000
2001 if ((expandoColumnModelImpl.getColumnBitmask() &
2002 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_T_N.getColumnBitmask()) != 0) {
2003 Object[] args = new Object[] {
2004 expandoColumnModelImpl.getOriginalTableId(),
2005 expandoColumnModelImpl.getOriginalName()
2006 };
2007
2008 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_T_N, args);
2009 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_T_N,
2010 args);
2011
2012 args = new Object[] {
2013 expandoColumnModelImpl.getTableId(),
2014 expandoColumnModelImpl.getName()
2015 };
2016
2017 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_T_N, args);
2018 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_T_N,
2019 args);
2020 }
2021 }
2022
2023 EntityCacheUtil.putResult(ExpandoColumnModelImpl.ENTITY_CACHE_ENABLED,
2024 ExpandoColumnImpl.class, expandoColumn.getPrimaryKey(),
2025 expandoColumn);
2026
2027 clearUniqueFindersCache(expandoColumn);
2028 cacheUniqueFindersCache(expandoColumn);
2029
2030 return expandoColumn;
2031 }
2032
2033 protected ExpandoColumn toUnwrappedModel(ExpandoColumn expandoColumn) {
2034 if (expandoColumn instanceof ExpandoColumnImpl) {
2035 return expandoColumn;
2036 }
2037
2038 ExpandoColumnImpl expandoColumnImpl = new ExpandoColumnImpl();
2039
2040 expandoColumnImpl.setNew(expandoColumn.isNew());
2041 expandoColumnImpl.setPrimaryKey(expandoColumn.getPrimaryKey());
2042
2043 expandoColumnImpl.setColumnId(expandoColumn.getColumnId());
2044 expandoColumnImpl.setCompanyId(expandoColumn.getCompanyId());
2045 expandoColumnImpl.setTableId(expandoColumn.getTableId());
2046 expandoColumnImpl.setName(expandoColumn.getName());
2047 expandoColumnImpl.setType(expandoColumn.getType());
2048 expandoColumnImpl.setDefaultData(expandoColumn.getDefaultData());
2049 expandoColumnImpl.setTypeSettings(expandoColumn.getTypeSettings());
2050
2051 return expandoColumnImpl;
2052 }
2053
2054
2062 @Override
2063 public ExpandoColumn findByPrimaryKey(Serializable primaryKey)
2064 throws NoSuchColumnException, SystemException {
2065 ExpandoColumn expandoColumn = fetchByPrimaryKey(primaryKey);
2066
2067 if (expandoColumn == null) {
2068 if (_log.isWarnEnabled()) {
2069 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey);
2070 }
2071
2072 throw new NoSuchColumnException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
2073 primaryKey);
2074 }
2075
2076 return expandoColumn;
2077 }
2078
2079
2087 @Override
2088 public ExpandoColumn findByPrimaryKey(long columnId)
2089 throws NoSuchColumnException, SystemException {
2090 return findByPrimaryKey((Serializable)columnId);
2091 }
2092
2093
2100 @Override
2101 public ExpandoColumn fetchByPrimaryKey(Serializable primaryKey)
2102 throws SystemException {
2103 ExpandoColumn expandoColumn = (ExpandoColumn)EntityCacheUtil.getResult(ExpandoColumnModelImpl.ENTITY_CACHE_ENABLED,
2104 ExpandoColumnImpl.class, primaryKey);
2105
2106 if (expandoColumn == _nullExpandoColumn) {
2107 return null;
2108 }
2109
2110 if (expandoColumn == null) {
2111 Session session = null;
2112
2113 try {
2114 session = openSession();
2115
2116 expandoColumn = (ExpandoColumn)session.get(ExpandoColumnImpl.class,
2117 primaryKey);
2118
2119 if (expandoColumn != null) {
2120 cacheResult(expandoColumn);
2121 }
2122 else {
2123 EntityCacheUtil.putResult(ExpandoColumnModelImpl.ENTITY_CACHE_ENABLED,
2124 ExpandoColumnImpl.class, primaryKey, _nullExpandoColumn);
2125 }
2126 }
2127 catch (Exception e) {
2128 EntityCacheUtil.removeResult(ExpandoColumnModelImpl.ENTITY_CACHE_ENABLED,
2129 ExpandoColumnImpl.class, primaryKey);
2130
2131 throw processException(e);
2132 }
2133 finally {
2134 closeSession(session);
2135 }
2136 }
2137
2138 return expandoColumn;
2139 }
2140
2141
2148 @Override
2149 public ExpandoColumn fetchByPrimaryKey(long columnId)
2150 throws SystemException {
2151 return fetchByPrimaryKey((Serializable)columnId);
2152 }
2153
2154
2160 @Override
2161 public List<ExpandoColumn> findAll() throws SystemException {
2162 return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
2163 }
2164
2165
2177 @Override
2178 public List<ExpandoColumn> findAll(int start, int end)
2179 throws SystemException {
2180 return findAll(start, end, null);
2181 }
2182
2183
2196 @Override
2197 public List<ExpandoColumn> findAll(int start, int end,
2198 OrderByComparator orderByComparator) throws SystemException {
2199 boolean pagination = true;
2200 FinderPath finderPath = null;
2201 Object[] finderArgs = null;
2202
2203 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
2204 (orderByComparator == null)) {
2205 pagination = false;
2206 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL;
2207 finderArgs = FINDER_ARGS_EMPTY;
2208 }
2209 else {
2210 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_ALL;
2211 finderArgs = new Object[] { start, end, orderByComparator };
2212 }
2213
2214 List<ExpandoColumn> list = (List<ExpandoColumn>)FinderCacheUtil.getResult(finderPath,
2215 finderArgs, this);
2216
2217 if (list == null) {
2218 StringBundler query = null;
2219 String sql = null;
2220
2221 if (orderByComparator != null) {
2222 query = new StringBundler(2 +
2223 (orderByComparator.getOrderByFields().length * 3));
2224
2225 query.append(_SQL_SELECT_EXPANDOCOLUMN);
2226
2227 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2228 orderByComparator);
2229
2230 sql = query.toString();
2231 }
2232 else {
2233 sql = _SQL_SELECT_EXPANDOCOLUMN;
2234
2235 if (pagination) {
2236 sql = sql.concat(ExpandoColumnModelImpl.ORDER_BY_JPQL);
2237 }
2238 }
2239
2240 Session session = null;
2241
2242 try {
2243 session = openSession();
2244
2245 Query q = session.createQuery(sql);
2246
2247 if (!pagination) {
2248 list = (List<ExpandoColumn>)QueryUtil.list(q, getDialect(),
2249 start, end, false);
2250
2251 Collections.sort(list);
2252
2253 list = new UnmodifiableList<ExpandoColumn>(list);
2254 }
2255 else {
2256 list = (List<ExpandoColumn>)QueryUtil.list(q, getDialect(),
2257 start, end);
2258 }
2259
2260 cacheResult(list);
2261
2262 FinderCacheUtil.putResult(finderPath, finderArgs, list);
2263 }
2264 catch (Exception e) {
2265 FinderCacheUtil.removeResult(finderPath, finderArgs);
2266
2267 throw processException(e);
2268 }
2269 finally {
2270 closeSession(session);
2271 }
2272 }
2273
2274 return list;
2275 }
2276
2277
2282 @Override
2283 public void removeAll() throws SystemException {
2284 for (ExpandoColumn expandoColumn : findAll()) {
2285 remove(expandoColumn);
2286 }
2287 }
2288
2289
2295 @Override
2296 public int countAll() throws SystemException {
2297 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
2298 FINDER_ARGS_EMPTY, this);
2299
2300 if (count == null) {
2301 Session session = null;
2302
2303 try {
2304 session = openSession();
2305
2306 Query q = session.createQuery(_SQL_COUNT_EXPANDOCOLUMN);
2307
2308 count = (Long)q.uniqueResult();
2309
2310 FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL,
2311 FINDER_ARGS_EMPTY, count);
2312 }
2313 catch (Exception e) {
2314 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_ALL,
2315 FINDER_ARGS_EMPTY);
2316
2317 throw processException(e);
2318 }
2319 finally {
2320 closeSession(session);
2321 }
2322 }
2323
2324 return count.intValue();
2325 }
2326
2327 @Override
2328 protected Set<String> getBadColumnNames() {
2329 return _badColumnNames;
2330 }
2331
2332
2335 public void afterPropertiesSet() {
2336 String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
2337 com.liferay.portal.util.PropsUtil.get(
2338 "value.object.listener.com.liferay.portlet.expando.model.ExpandoColumn")));
2339
2340 if (listenerClassNames.length > 0) {
2341 try {
2342 List<ModelListener<ExpandoColumn>> listenersList = new ArrayList<ModelListener<ExpandoColumn>>();
2343
2344 for (String listenerClassName : listenerClassNames) {
2345 listenersList.add((ModelListener<ExpandoColumn>)InstanceFactory.newInstance(
2346 getClassLoader(), listenerClassName));
2347 }
2348
2349 listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
2350 }
2351 catch (Exception e) {
2352 _log.error(e);
2353 }
2354 }
2355 }
2356
2357 public void destroy() {
2358 EntityCacheUtil.removeCache(ExpandoColumnImpl.class.getName());
2359 FinderCacheUtil.removeCache(FINDER_CLASS_NAME_ENTITY);
2360 FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
2361 FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
2362 }
2363
2364 private static final String _SQL_SELECT_EXPANDOCOLUMN = "SELECT expandoColumn FROM ExpandoColumn expandoColumn";
2365 private static final String _SQL_SELECT_EXPANDOCOLUMN_WHERE = "SELECT expandoColumn FROM ExpandoColumn expandoColumn WHERE ";
2366 private static final String _SQL_COUNT_EXPANDOCOLUMN = "SELECT COUNT(expandoColumn) FROM ExpandoColumn expandoColumn";
2367 private static final String _SQL_COUNT_EXPANDOCOLUMN_WHERE = "SELECT COUNT(expandoColumn) FROM ExpandoColumn expandoColumn WHERE ";
2368 private static final String _FILTER_ENTITY_TABLE_FILTER_PK_COLUMN = "expandoColumn.columnId";
2369 private static final String _FILTER_SQL_SELECT_EXPANDOCOLUMN_WHERE = "SELECT DISTINCT {expandoColumn.*} FROM ExpandoColumn expandoColumn WHERE ";
2370 private static final String _FILTER_SQL_SELECT_EXPANDOCOLUMN_NO_INLINE_DISTINCT_WHERE_1 =
2371 "SELECT {ExpandoColumn.*} FROM (SELECT DISTINCT expandoColumn.columnId FROM ExpandoColumn expandoColumn WHERE ";
2372 private static final String _FILTER_SQL_SELECT_EXPANDOCOLUMN_NO_INLINE_DISTINCT_WHERE_2 =
2373 ") TEMP_TABLE INNER JOIN ExpandoColumn ON TEMP_TABLE.columnId = ExpandoColumn.columnId";
2374 private static final String _FILTER_SQL_COUNT_EXPANDOCOLUMN_WHERE = "SELECT COUNT(DISTINCT expandoColumn.columnId) AS COUNT_VALUE FROM ExpandoColumn expandoColumn WHERE ";
2375 private static final String _FILTER_ENTITY_ALIAS = "expandoColumn";
2376 private static final String _FILTER_ENTITY_TABLE = "ExpandoColumn";
2377 private static final String _ORDER_BY_ENTITY_ALIAS = "expandoColumn.";
2378 private static final String _ORDER_BY_ENTITY_TABLE = "ExpandoColumn.";
2379 private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No ExpandoColumn exists with the primary key ";
2380 private static final String _NO_SUCH_ENTITY_WITH_KEY = "No ExpandoColumn exists with the key {";
2381 private static final boolean _HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE = com.liferay.portal.util.PropsValues.HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE;
2382 private static Log _log = LogFactoryUtil.getLog(ExpandoColumnPersistenceImpl.class);
2383 private static Set<String> _badColumnNames = SetUtil.fromArray(new String[] {
2384 "type"
2385 });
2386 private static ExpandoColumn _nullExpandoColumn = new ExpandoColumnImpl() {
2387 @Override
2388 public Object clone() {
2389 return this;
2390 }
2391
2392 @Override
2393 public CacheModel<ExpandoColumn> toCacheModel() {
2394 return _nullExpandoColumnCacheModel;
2395 }
2396 };
2397
2398 private static CacheModel<ExpandoColumn> _nullExpandoColumnCacheModel = new CacheModel<ExpandoColumn>() {
2399 @Override
2400 public ExpandoColumn toEntityModel() {
2401 return _nullExpandoColumn;
2402 }
2403 };
2404 }