001
014
015 package com.liferay.portlet.dynamicdatalists.service.persistence.impl;
016
017 import aQute.bnd.annotation.ProviderType;
018
019 import com.liferay.portal.kernel.cache.CacheRegistryUtil;
020 import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
021 import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
022 import com.liferay.portal.kernel.dao.orm.FinderPath;
023 import com.liferay.portal.kernel.dao.orm.Query;
024 import com.liferay.portal.kernel.dao.orm.QueryPos;
025 import com.liferay.portal.kernel.dao.orm.QueryUtil;
026 import com.liferay.portal.kernel.dao.orm.SQLQuery;
027 import com.liferay.portal.kernel.dao.orm.Session;
028 import com.liferay.portal.kernel.log.Log;
029 import com.liferay.portal.kernel.log.LogFactoryUtil;
030 import com.liferay.portal.kernel.util.OrderByComparator;
031 import com.liferay.portal.kernel.util.SetUtil;
032 import com.liferay.portal.kernel.util.StringBundler;
033 import com.liferay.portal.kernel.util.StringPool;
034 import com.liferay.portal.kernel.util.Validator;
035 import com.liferay.portal.kernel.uuid.PortalUUIDUtil;
036 import com.liferay.portal.model.CacheModel;
037 import com.liferay.portal.security.permission.InlineSQLHelperUtil;
038 import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
039
040 import com.liferay.portlet.dynamicdatalists.NoSuchRecordSetException;
041 import com.liferay.portlet.dynamicdatalists.model.DDLRecordSet;
042 import com.liferay.portlet.dynamicdatalists.model.impl.DDLRecordSetImpl;
043 import com.liferay.portlet.dynamicdatalists.model.impl.DDLRecordSetModelImpl;
044 import com.liferay.portlet.dynamicdatalists.service.persistence.DDLRecordSetPersistence;
045
046 import java.io.Serializable;
047
048 import java.util.Collections;
049 import java.util.HashMap;
050 import java.util.HashSet;
051 import java.util.Iterator;
052 import java.util.List;
053 import java.util.Map;
054 import java.util.Set;
055
056
068 @ProviderType
069 public class DDLRecordSetPersistenceImpl extends BasePersistenceImpl<DDLRecordSet>
070 implements DDLRecordSetPersistence {
071
076 public static final String FINDER_CLASS_NAME_ENTITY = DDLRecordSetImpl.class.getName();
077 public static final String FINDER_CLASS_NAME_LIST_WITH_PAGINATION = FINDER_CLASS_NAME_ENTITY +
078 ".List1";
079 public static final String FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION = FINDER_CLASS_NAME_ENTITY +
080 ".List2";
081 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_ALL = new FinderPath(DDLRecordSetModelImpl.ENTITY_CACHE_ENABLED,
082 DDLRecordSetModelImpl.FINDER_CACHE_ENABLED, DDLRecordSetImpl.class,
083 FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findAll", new String[0]);
084 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL = new FinderPath(DDLRecordSetModelImpl.ENTITY_CACHE_ENABLED,
085 DDLRecordSetModelImpl.FINDER_CACHE_ENABLED, DDLRecordSetImpl.class,
086 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findAll", new String[0]);
087 public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(DDLRecordSetModelImpl.ENTITY_CACHE_ENABLED,
088 DDLRecordSetModelImpl.FINDER_CACHE_ENABLED, Long.class,
089 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countAll", new String[0]);
090 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_UUID = new FinderPath(DDLRecordSetModelImpl.ENTITY_CACHE_ENABLED,
091 DDLRecordSetModelImpl.FINDER_CACHE_ENABLED, DDLRecordSetImpl.class,
092 FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByUuid",
093 new String[] {
094 String.class.getName(),
095
096 Integer.class.getName(), Integer.class.getName(),
097 OrderByComparator.class.getName()
098 });
099 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID = new FinderPath(DDLRecordSetModelImpl.ENTITY_CACHE_ENABLED,
100 DDLRecordSetModelImpl.FINDER_CACHE_ENABLED, DDLRecordSetImpl.class,
101 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByUuid",
102 new String[] { String.class.getName() },
103 DDLRecordSetModelImpl.UUID_COLUMN_BITMASK);
104 public static final FinderPath FINDER_PATH_COUNT_BY_UUID = new FinderPath(DDLRecordSetModelImpl.ENTITY_CACHE_ENABLED,
105 DDLRecordSetModelImpl.FINDER_CACHE_ENABLED, Long.class,
106 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByUuid",
107 new String[] { String.class.getName() });
108
109
115 @Override
116 public List<DDLRecordSet> findByUuid(String uuid) {
117 return findByUuid(uuid, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
118 }
119
120
132 @Override
133 public List<DDLRecordSet> findByUuid(String uuid, int start, int end) {
134 return findByUuid(uuid, start, end, null);
135 }
136
137
150 @Override
151 public List<DDLRecordSet> findByUuid(String uuid, int start, int end,
152 OrderByComparator<DDLRecordSet> orderByComparator) {
153 boolean pagination = true;
154 FinderPath finderPath = null;
155 Object[] finderArgs = null;
156
157 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
158 (orderByComparator == null)) {
159 pagination = false;
160 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID;
161 finderArgs = new Object[] { uuid };
162 }
163 else {
164 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_UUID;
165 finderArgs = new Object[] { uuid, start, end, orderByComparator };
166 }
167
168 List<DDLRecordSet> list = (List<DDLRecordSet>)FinderCacheUtil.getResult(finderPath,
169 finderArgs, this);
170
171 if ((list != null) && !list.isEmpty()) {
172 for (DDLRecordSet ddlRecordSet : list) {
173 if (!Validator.equals(uuid, ddlRecordSet.getUuid())) {
174 list = null;
175
176 break;
177 }
178 }
179 }
180
181 if (list == null) {
182 StringBundler query = null;
183
184 if (orderByComparator != null) {
185 query = new StringBundler(3 +
186 (orderByComparator.getOrderByFields().length * 3));
187 }
188 else {
189 query = new StringBundler(3);
190 }
191
192 query.append(_SQL_SELECT_DDLRECORDSET_WHERE);
193
194 boolean bindUuid = false;
195
196 if (uuid == null) {
197 query.append(_FINDER_COLUMN_UUID_UUID_1);
198 }
199 else if (uuid.equals(StringPool.BLANK)) {
200 query.append(_FINDER_COLUMN_UUID_UUID_3);
201 }
202 else {
203 bindUuid = true;
204
205 query.append(_FINDER_COLUMN_UUID_UUID_2);
206 }
207
208 if (orderByComparator != null) {
209 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
210 orderByComparator);
211 }
212 else
213 if (pagination) {
214 query.append(DDLRecordSetModelImpl.ORDER_BY_JPQL);
215 }
216
217 String sql = query.toString();
218
219 Session session = null;
220
221 try {
222 session = openSession();
223
224 Query q = session.createQuery(sql);
225
226 QueryPos qPos = QueryPos.getInstance(q);
227
228 if (bindUuid) {
229 qPos.add(uuid);
230 }
231
232 if (!pagination) {
233 list = (List<DDLRecordSet>)QueryUtil.list(q, getDialect(),
234 start, end, false);
235
236 Collections.sort(list);
237
238 list = Collections.unmodifiableList(list);
239 }
240 else {
241 list = (List<DDLRecordSet>)QueryUtil.list(q, getDialect(),
242 start, end);
243 }
244
245 cacheResult(list);
246
247 FinderCacheUtil.putResult(finderPath, finderArgs, list);
248 }
249 catch (Exception e) {
250 FinderCacheUtil.removeResult(finderPath, finderArgs);
251
252 throw processException(e);
253 }
254 finally {
255 closeSession(session);
256 }
257 }
258
259 return list;
260 }
261
262
270 @Override
271 public DDLRecordSet findByUuid_First(String uuid,
272 OrderByComparator<DDLRecordSet> orderByComparator)
273 throws NoSuchRecordSetException {
274 DDLRecordSet ddlRecordSet = fetchByUuid_First(uuid, orderByComparator);
275
276 if (ddlRecordSet != null) {
277 return ddlRecordSet;
278 }
279
280 StringBundler msg = new StringBundler(4);
281
282 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
283
284 msg.append("uuid=");
285 msg.append(uuid);
286
287 msg.append(StringPool.CLOSE_CURLY_BRACE);
288
289 throw new NoSuchRecordSetException(msg.toString());
290 }
291
292
299 @Override
300 public DDLRecordSet fetchByUuid_First(String uuid,
301 OrderByComparator<DDLRecordSet> orderByComparator) {
302 List<DDLRecordSet> list = findByUuid(uuid, 0, 1, orderByComparator);
303
304 if (!list.isEmpty()) {
305 return list.get(0);
306 }
307
308 return null;
309 }
310
311
319 @Override
320 public DDLRecordSet findByUuid_Last(String uuid,
321 OrderByComparator<DDLRecordSet> orderByComparator)
322 throws NoSuchRecordSetException {
323 DDLRecordSet ddlRecordSet = fetchByUuid_Last(uuid, orderByComparator);
324
325 if (ddlRecordSet != null) {
326 return ddlRecordSet;
327 }
328
329 StringBundler msg = new StringBundler(4);
330
331 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
332
333 msg.append("uuid=");
334 msg.append(uuid);
335
336 msg.append(StringPool.CLOSE_CURLY_BRACE);
337
338 throw new NoSuchRecordSetException(msg.toString());
339 }
340
341
348 @Override
349 public DDLRecordSet fetchByUuid_Last(String uuid,
350 OrderByComparator<DDLRecordSet> orderByComparator) {
351 int count = countByUuid(uuid);
352
353 if (count == 0) {
354 return null;
355 }
356
357 List<DDLRecordSet> list = findByUuid(uuid, count - 1, count,
358 orderByComparator);
359
360 if (!list.isEmpty()) {
361 return list.get(0);
362 }
363
364 return null;
365 }
366
367
376 @Override
377 public DDLRecordSet[] findByUuid_PrevAndNext(long recordSetId, String uuid,
378 OrderByComparator<DDLRecordSet> orderByComparator)
379 throws NoSuchRecordSetException {
380 DDLRecordSet ddlRecordSet = findByPrimaryKey(recordSetId);
381
382 Session session = null;
383
384 try {
385 session = openSession();
386
387 DDLRecordSet[] array = new DDLRecordSetImpl[3];
388
389 array[0] = getByUuid_PrevAndNext(session, ddlRecordSet, uuid,
390 orderByComparator, true);
391
392 array[1] = ddlRecordSet;
393
394 array[2] = getByUuid_PrevAndNext(session, ddlRecordSet, uuid,
395 orderByComparator, false);
396
397 return array;
398 }
399 catch (Exception e) {
400 throw processException(e);
401 }
402 finally {
403 closeSession(session);
404 }
405 }
406
407 protected DDLRecordSet getByUuid_PrevAndNext(Session session,
408 DDLRecordSet ddlRecordSet, String uuid,
409 OrderByComparator<DDLRecordSet> orderByComparator, boolean previous) {
410 StringBundler query = null;
411
412 if (orderByComparator != null) {
413 query = new StringBundler(6 +
414 (orderByComparator.getOrderByFields().length * 6));
415 }
416 else {
417 query = new StringBundler(3);
418 }
419
420 query.append(_SQL_SELECT_DDLRECORDSET_WHERE);
421
422 boolean bindUuid = false;
423
424 if (uuid == null) {
425 query.append(_FINDER_COLUMN_UUID_UUID_1);
426 }
427 else if (uuid.equals(StringPool.BLANK)) {
428 query.append(_FINDER_COLUMN_UUID_UUID_3);
429 }
430 else {
431 bindUuid = true;
432
433 query.append(_FINDER_COLUMN_UUID_UUID_2);
434 }
435
436 if (orderByComparator != null) {
437 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
438
439 if (orderByConditionFields.length > 0) {
440 query.append(WHERE_AND);
441 }
442
443 for (int i = 0; i < orderByConditionFields.length; i++) {
444 query.append(_ORDER_BY_ENTITY_ALIAS);
445 query.append(orderByConditionFields[i]);
446
447 if ((i + 1) < orderByConditionFields.length) {
448 if (orderByComparator.isAscending() ^ previous) {
449 query.append(WHERE_GREATER_THAN_HAS_NEXT);
450 }
451 else {
452 query.append(WHERE_LESSER_THAN_HAS_NEXT);
453 }
454 }
455 else {
456 if (orderByComparator.isAscending() ^ previous) {
457 query.append(WHERE_GREATER_THAN);
458 }
459 else {
460 query.append(WHERE_LESSER_THAN);
461 }
462 }
463 }
464
465 query.append(ORDER_BY_CLAUSE);
466
467 String[] orderByFields = orderByComparator.getOrderByFields();
468
469 for (int i = 0; i < orderByFields.length; i++) {
470 query.append(_ORDER_BY_ENTITY_ALIAS);
471 query.append(orderByFields[i]);
472
473 if ((i + 1) < orderByFields.length) {
474 if (orderByComparator.isAscending() ^ previous) {
475 query.append(ORDER_BY_ASC_HAS_NEXT);
476 }
477 else {
478 query.append(ORDER_BY_DESC_HAS_NEXT);
479 }
480 }
481 else {
482 if (orderByComparator.isAscending() ^ previous) {
483 query.append(ORDER_BY_ASC);
484 }
485 else {
486 query.append(ORDER_BY_DESC);
487 }
488 }
489 }
490 }
491 else {
492 query.append(DDLRecordSetModelImpl.ORDER_BY_JPQL);
493 }
494
495 String sql = query.toString();
496
497 Query q = session.createQuery(sql);
498
499 q.setFirstResult(0);
500 q.setMaxResults(2);
501
502 QueryPos qPos = QueryPos.getInstance(q);
503
504 if (bindUuid) {
505 qPos.add(uuid);
506 }
507
508 if (orderByComparator != null) {
509 Object[] values = orderByComparator.getOrderByConditionValues(ddlRecordSet);
510
511 for (Object value : values) {
512 qPos.add(value);
513 }
514 }
515
516 List<DDLRecordSet> list = q.list();
517
518 if (list.size() == 2) {
519 return list.get(1);
520 }
521 else {
522 return null;
523 }
524 }
525
526
531 @Override
532 public void removeByUuid(String uuid) {
533 for (DDLRecordSet ddlRecordSet : findByUuid(uuid, QueryUtil.ALL_POS,
534 QueryUtil.ALL_POS, null)) {
535 remove(ddlRecordSet);
536 }
537 }
538
539
545 @Override
546 public int countByUuid(String uuid) {
547 FinderPath finderPath = FINDER_PATH_COUNT_BY_UUID;
548
549 Object[] finderArgs = new Object[] { uuid };
550
551 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
552 this);
553
554 if (count == null) {
555 StringBundler query = new StringBundler(2);
556
557 query.append(_SQL_COUNT_DDLRECORDSET_WHERE);
558
559 boolean bindUuid = false;
560
561 if (uuid == null) {
562 query.append(_FINDER_COLUMN_UUID_UUID_1);
563 }
564 else if (uuid.equals(StringPool.BLANK)) {
565 query.append(_FINDER_COLUMN_UUID_UUID_3);
566 }
567 else {
568 bindUuid = true;
569
570 query.append(_FINDER_COLUMN_UUID_UUID_2);
571 }
572
573 String sql = query.toString();
574
575 Session session = null;
576
577 try {
578 session = openSession();
579
580 Query q = session.createQuery(sql);
581
582 QueryPos qPos = QueryPos.getInstance(q);
583
584 if (bindUuid) {
585 qPos.add(uuid);
586 }
587
588 count = (Long)q.uniqueResult();
589
590 FinderCacheUtil.putResult(finderPath, finderArgs, count);
591 }
592 catch (Exception e) {
593 FinderCacheUtil.removeResult(finderPath, finderArgs);
594
595 throw processException(e);
596 }
597 finally {
598 closeSession(session);
599 }
600 }
601
602 return count.intValue();
603 }
604
605 private static final String _FINDER_COLUMN_UUID_UUID_1 = "ddlRecordSet.uuid IS NULL";
606 private static final String _FINDER_COLUMN_UUID_UUID_2 = "ddlRecordSet.uuid = ?";
607 private static final String _FINDER_COLUMN_UUID_UUID_3 = "(ddlRecordSet.uuid IS NULL OR ddlRecordSet.uuid = '')";
608 public static final FinderPath FINDER_PATH_FETCH_BY_UUID_G = new FinderPath(DDLRecordSetModelImpl.ENTITY_CACHE_ENABLED,
609 DDLRecordSetModelImpl.FINDER_CACHE_ENABLED, DDLRecordSetImpl.class,
610 FINDER_CLASS_NAME_ENTITY, "fetchByUUID_G",
611 new String[] { String.class.getName(), Long.class.getName() },
612 DDLRecordSetModelImpl.UUID_COLUMN_BITMASK |
613 DDLRecordSetModelImpl.GROUPID_COLUMN_BITMASK);
614 public static final FinderPath FINDER_PATH_COUNT_BY_UUID_G = new FinderPath(DDLRecordSetModelImpl.ENTITY_CACHE_ENABLED,
615 DDLRecordSetModelImpl.FINDER_CACHE_ENABLED, Long.class,
616 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByUUID_G",
617 new String[] { String.class.getName(), Long.class.getName() });
618
619
627 @Override
628 public DDLRecordSet findByUUID_G(String uuid, long groupId)
629 throws NoSuchRecordSetException {
630 DDLRecordSet ddlRecordSet = fetchByUUID_G(uuid, groupId);
631
632 if (ddlRecordSet == null) {
633 StringBundler msg = new StringBundler(6);
634
635 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
636
637 msg.append("uuid=");
638 msg.append(uuid);
639
640 msg.append(", groupId=");
641 msg.append(groupId);
642
643 msg.append(StringPool.CLOSE_CURLY_BRACE);
644
645 if (_log.isWarnEnabled()) {
646 _log.warn(msg.toString());
647 }
648
649 throw new NoSuchRecordSetException(msg.toString());
650 }
651
652 return ddlRecordSet;
653 }
654
655
662 @Override
663 public DDLRecordSet fetchByUUID_G(String uuid, long groupId) {
664 return fetchByUUID_G(uuid, groupId, true);
665 }
666
667
675 @Override
676 public DDLRecordSet fetchByUUID_G(String uuid, long groupId,
677 boolean retrieveFromCache) {
678 Object[] finderArgs = new Object[] { uuid, groupId };
679
680 Object result = null;
681
682 if (retrieveFromCache) {
683 result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_UUID_G,
684 finderArgs, this);
685 }
686
687 if (result instanceof DDLRecordSet) {
688 DDLRecordSet ddlRecordSet = (DDLRecordSet)result;
689
690 if (!Validator.equals(uuid, ddlRecordSet.getUuid()) ||
691 (groupId != ddlRecordSet.getGroupId())) {
692 result = null;
693 }
694 }
695
696 if (result == null) {
697 StringBundler query = new StringBundler(4);
698
699 query.append(_SQL_SELECT_DDLRECORDSET_WHERE);
700
701 boolean bindUuid = false;
702
703 if (uuid == null) {
704 query.append(_FINDER_COLUMN_UUID_G_UUID_1);
705 }
706 else if (uuid.equals(StringPool.BLANK)) {
707 query.append(_FINDER_COLUMN_UUID_G_UUID_3);
708 }
709 else {
710 bindUuid = true;
711
712 query.append(_FINDER_COLUMN_UUID_G_UUID_2);
713 }
714
715 query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
716
717 String sql = query.toString();
718
719 Session session = null;
720
721 try {
722 session = openSession();
723
724 Query q = session.createQuery(sql);
725
726 QueryPos qPos = QueryPos.getInstance(q);
727
728 if (bindUuid) {
729 qPos.add(uuid);
730 }
731
732 qPos.add(groupId);
733
734 List<DDLRecordSet> list = q.list();
735
736 if (list.isEmpty()) {
737 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
738 finderArgs, list);
739 }
740 else {
741 DDLRecordSet ddlRecordSet = list.get(0);
742
743 result = ddlRecordSet;
744
745 cacheResult(ddlRecordSet);
746
747 if ((ddlRecordSet.getUuid() == null) ||
748 !ddlRecordSet.getUuid().equals(uuid) ||
749 (ddlRecordSet.getGroupId() != groupId)) {
750 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
751 finderArgs, ddlRecordSet);
752 }
753 }
754 }
755 catch (Exception e) {
756 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
757 finderArgs);
758
759 throw processException(e);
760 }
761 finally {
762 closeSession(session);
763 }
764 }
765
766 if (result instanceof List<?>) {
767 return null;
768 }
769 else {
770 return (DDLRecordSet)result;
771 }
772 }
773
774
781 @Override
782 public DDLRecordSet removeByUUID_G(String uuid, long groupId)
783 throws NoSuchRecordSetException {
784 DDLRecordSet ddlRecordSet = findByUUID_G(uuid, groupId);
785
786 return remove(ddlRecordSet);
787 }
788
789
796 @Override
797 public int countByUUID_G(String uuid, long groupId) {
798 FinderPath finderPath = FINDER_PATH_COUNT_BY_UUID_G;
799
800 Object[] finderArgs = new Object[] { uuid, groupId };
801
802 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
803 this);
804
805 if (count == null) {
806 StringBundler query = new StringBundler(3);
807
808 query.append(_SQL_COUNT_DDLRECORDSET_WHERE);
809
810 boolean bindUuid = false;
811
812 if (uuid == null) {
813 query.append(_FINDER_COLUMN_UUID_G_UUID_1);
814 }
815 else if (uuid.equals(StringPool.BLANK)) {
816 query.append(_FINDER_COLUMN_UUID_G_UUID_3);
817 }
818 else {
819 bindUuid = true;
820
821 query.append(_FINDER_COLUMN_UUID_G_UUID_2);
822 }
823
824 query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
825
826 String sql = query.toString();
827
828 Session session = null;
829
830 try {
831 session = openSession();
832
833 Query q = session.createQuery(sql);
834
835 QueryPos qPos = QueryPos.getInstance(q);
836
837 if (bindUuid) {
838 qPos.add(uuid);
839 }
840
841 qPos.add(groupId);
842
843 count = (Long)q.uniqueResult();
844
845 FinderCacheUtil.putResult(finderPath, finderArgs, count);
846 }
847 catch (Exception e) {
848 FinderCacheUtil.removeResult(finderPath, finderArgs);
849
850 throw processException(e);
851 }
852 finally {
853 closeSession(session);
854 }
855 }
856
857 return count.intValue();
858 }
859
860 private static final String _FINDER_COLUMN_UUID_G_UUID_1 = "ddlRecordSet.uuid IS NULL AND ";
861 private static final String _FINDER_COLUMN_UUID_G_UUID_2 = "ddlRecordSet.uuid = ? AND ";
862 private static final String _FINDER_COLUMN_UUID_G_UUID_3 = "(ddlRecordSet.uuid IS NULL OR ddlRecordSet.uuid = '') AND ";
863 private static final String _FINDER_COLUMN_UUID_G_GROUPID_2 = "ddlRecordSet.groupId = ?";
864 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_UUID_C = new FinderPath(DDLRecordSetModelImpl.ENTITY_CACHE_ENABLED,
865 DDLRecordSetModelImpl.FINDER_CACHE_ENABLED, DDLRecordSetImpl.class,
866 FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByUuid_C",
867 new String[] {
868 String.class.getName(), Long.class.getName(),
869
870 Integer.class.getName(), Integer.class.getName(),
871 OrderByComparator.class.getName()
872 });
873 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C =
874 new FinderPath(DDLRecordSetModelImpl.ENTITY_CACHE_ENABLED,
875 DDLRecordSetModelImpl.FINDER_CACHE_ENABLED, DDLRecordSetImpl.class,
876 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByUuid_C",
877 new String[] { String.class.getName(), Long.class.getName() },
878 DDLRecordSetModelImpl.UUID_COLUMN_BITMASK |
879 DDLRecordSetModelImpl.COMPANYID_COLUMN_BITMASK);
880 public static final FinderPath FINDER_PATH_COUNT_BY_UUID_C = new FinderPath(DDLRecordSetModelImpl.ENTITY_CACHE_ENABLED,
881 DDLRecordSetModelImpl.FINDER_CACHE_ENABLED, Long.class,
882 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByUuid_C",
883 new String[] { String.class.getName(), Long.class.getName() });
884
885
892 @Override
893 public List<DDLRecordSet> findByUuid_C(String uuid, long companyId) {
894 return findByUuid_C(uuid, companyId, QueryUtil.ALL_POS,
895 QueryUtil.ALL_POS, null);
896 }
897
898
911 @Override
912 public List<DDLRecordSet> findByUuid_C(String uuid, long companyId,
913 int start, int end) {
914 return findByUuid_C(uuid, companyId, start, end, null);
915 }
916
917
931 @Override
932 public List<DDLRecordSet> findByUuid_C(String uuid, long companyId,
933 int start, int end, OrderByComparator<DDLRecordSet> orderByComparator) {
934 boolean pagination = true;
935 FinderPath finderPath = null;
936 Object[] finderArgs = null;
937
938 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
939 (orderByComparator == null)) {
940 pagination = false;
941 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C;
942 finderArgs = new Object[] { uuid, companyId };
943 }
944 else {
945 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_UUID_C;
946 finderArgs = new Object[] {
947 uuid, companyId,
948
949 start, end, orderByComparator
950 };
951 }
952
953 List<DDLRecordSet> list = (List<DDLRecordSet>)FinderCacheUtil.getResult(finderPath,
954 finderArgs, this);
955
956 if ((list != null) && !list.isEmpty()) {
957 for (DDLRecordSet ddlRecordSet : list) {
958 if (!Validator.equals(uuid, ddlRecordSet.getUuid()) ||
959 (companyId != ddlRecordSet.getCompanyId())) {
960 list = null;
961
962 break;
963 }
964 }
965 }
966
967 if (list == null) {
968 StringBundler query = null;
969
970 if (orderByComparator != null) {
971 query = new StringBundler(4 +
972 (orderByComparator.getOrderByFields().length * 3));
973 }
974 else {
975 query = new StringBundler(4);
976 }
977
978 query.append(_SQL_SELECT_DDLRECORDSET_WHERE);
979
980 boolean bindUuid = false;
981
982 if (uuid == null) {
983 query.append(_FINDER_COLUMN_UUID_C_UUID_1);
984 }
985 else if (uuid.equals(StringPool.BLANK)) {
986 query.append(_FINDER_COLUMN_UUID_C_UUID_3);
987 }
988 else {
989 bindUuid = true;
990
991 query.append(_FINDER_COLUMN_UUID_C_UUID_2);
992 }
993
994 query.append(_FINDER_COLUMN_UUID_C_COMPANYID_2);
995
996 if (orderByComparator != null) {
997 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
998 orderByComparator);
999 }
1000 else
1001 if (pagination) {
1002 query.append(DDLRecordSetModelImpl.ORDER_BY_JPQL);
1003 }
1004
1005 String sql = query.toString();
1006
1007 Session session = null;
1008
1009 try {
1010 session = openSession();
1011
1012 Query q = session.createQuery(sql);
1013
1014 QueryPos qPos = QueryPos.getInstance(q);
1015
1016 if (bindUuid) {
1017 qPos.add(uuid);
1018 }
1019
1020 qPos.add(companyId);
1021
1022 if (!pagination) {
1023 list = (List<DDLRecordSet>)QueryUtil.list(q, getDialect(),
1024 start, end, false);
1025
1026 Collections.sort(list);
1027
1028 list = Collections.unmodifiableList(list);
1029 }
1030 else {
1031 list = (List<DDLRecordSet>)QueryUtil.list(q, getDialect(),
1032 start, end);
1033 }
1034
1035 cacheResult(list);
1036
1037 FinderCacheUtil.putResult(finderPath, finderArgs, list);
1038 }
1039 catch (Exception e) {
1040 FinderCacheUtil.removeResult(finderPath, finderArgs);
1041
1042 throw processException(e);
1043 }
1044 finally {
1045 closeSession(session);
1046 }
1047 }
1048
1049 return list;
1050 }
1051
1052
1061 @Override
1062 public DDLRecordSet findByUuid_C_First(String uuid, long companyId,
1063 OrderByComparator<DDLRecordSet> orderByComparator)
1064 throws NoSuchRecordSetException {
1065 DDLRecordSet ddlRecordSet = fetchByUuid_C_First(uuid, companyId,
1066 orderByComparator);
1067
1068 if (ddlRecordSet != null) {
1069 return ddlRecordSet;
1070 }
1071
1072 StringBundler msg = new StringBundler(6);
1073
1074 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1075
1076 msg.append("uuid=");
1077 msg.append(uuid);
1078
1079 msg.append(", companyId=");
1080 msg.append(companyId);
1081
1082 msg.append(StringPool.CLOSE_CURLY_BRACE);
1083
1084 throw new NoSuchRecordSetException(msg.toString());
1085 }
1086
1087
1095 @Override
1096 public DDLRecordSet fetchByUuid_C_First(String uuid, long companyId,
1097 OrderByComparator<DDLRecordSet> orderByComparator) {
1098 List<DDLRecordSet> list = findByUuid_C(uuid, companyId, 0, 1,
1099 orderByComparator);
1100
1101 if (!list.isEmpty()) {
1102 return list.get(0);
1103 }
1104
1105 return null;
1106 }
1107
1108
1117 @Override
1118 public DDLRecordSet findByUuid_C_Last(String uuid, long companyId,
1119 OrderByComparator<DDLRecordSet> orderByComparator)
1120 throws NoSuchRecordSetException {
1121 DDLRecordSet ddlRecordSet = fetchByUuid_C_Last(uuid, companyId,
1122 orderByComparator);
1123
1124 if (ddlRecordSet != null) {
1125 return ddlRecordSet;
1126 }
1127
1128 StringBundler msg = new StringBundler(6);
1129
1130 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1131
1132 msg.append("uuid=");
1133 msg.append(uuid);
1134
1135 msg.append(", companyId=");
1136 msg.append(companyId);
1137
1138 msg.append(StringPool.CLOSE_CURLY_BRACE);
1139
1140 throw new NoSuchRecordSetException(msg.toString());
1141 }
1142
1143
1151 @Override
1152 public DDLRecordSet fetchByUuid_C_Last(String uuid, long companyId,
1153 OrderByComparator<DDLRecordSet> orderByComparator) {
1154 int count = countByUuid_C(uuid, companyId);
1155
1156 if (count == 0) {
1157 return null;
1158 }
1159
1160 List<DDLRecordSet> list = findByUuid_C(uuid, companyId, count - 1,
1161 count, orderByComparator);
1162
1163 if (!list.isEmpty()) {
1164 return list.get(0);
1165 }
1166
1167 return null;
1168 }
1169
1170
1180 @Override
1181 public DDLRecordSet[] findByUuid_C_PrevAndNext(long recordSetId,
1182 String uuid, long companyId,
1183 OrderByComparator<DDLRecordSet> orderByComparator)
1184 throws NoSuchRecordSetException {
1185 DDLRecordSet ddlRecordSet = findByPrimaryKey(recordSetId);
1186
1187 Session session = null;
1188
1189 try {
1190 session = openSession();
1191
1192 DDLRecordSet[] array = new DDLRecordSetImpl[3];
1193
1194 array[0] = getByUuid_C_PrevAndNext(session, ddlRecordSet, uuid,
1195 companyId, orderByComparator, true);
1196
1197 array[1] = ddlRecordSet;
1198
1199 array[2] = getByUuid_C_PrevAndNext(session, ddlRecordSet, uuid,
1200 companyId, orderByComparator, false);
1201
1202 return array;
1203 }
1204 catch (Exception e) {
1205 throw processException(e);
1206 }
1207 finally {
1208 closeSession(session);
1209 }
1210 }
1211
1212 protected DDLRecordSet getByUuid_C_PrevAndNext(Session session,
1213 DDLRecordSet ddlRecordSet, String uuid, long companyId,
1214 OrderByComparator<DDLRecordSet> orderByComparator, boolean previous) {
1215 StringBundler query = null;
1216
1217 if (orderByComparator != null) {
1218 query = new StringBundler(6 +
1219 (orderByComparator.getOrderByFields().length * 6));
1220 }
1221 else {
1222 query = new StringBundler(3);
1223 }
1224
1225 query.append(_SQL_SELECT_DDLRECORDSET_WHERE);
1226
1227 boolean bindUuid = false;
1228
1229 if (uuid == null) {
1230 query.append(_FINDER_COLUMN_UUID_C_UUID_1);
1231 }
1232 else if (uuid.equals(StringPool.BLANK)) {
1233 query.append(_FINDER_COLUMN_UUID_C_UUID_3);
1234 }
1235 else {
1236 bindUuid = true;
1237
1238 query.append(_FINDER_COLUMN_UUID_C_UUID_2);
1239 }
1240
1241 query.append(_FINDER_COLUMN_UUID_C_COMPANYID_2);
1242
1243 if (orderByComparator != null) {
1244 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
1245
1246 if (orderByConditionFields.length > 0) {
1247 query.append(WHERE_AND);
1248 }
1249
1250 for (int i = 0; i < orderByConditionFields.length; i++) {
1251 query.append(_ORDER_BY_ENTITY_ALIAS);
1252 query.append(orderByConditionFields[i]);
1253
1254 if ((i + 1) < orderByConditionFields.length) {
1255 if (orderByComparator.isAscending() ^ previous) {
1256 query.append(WHERE_GREATER_THAN_HAS_NEXT);
1257 }
1258 else {
1259 query.append(WHERE_LESSER_THAN_HAS_NEXT);
1260 }
1261 }
1262 else {
1263 if (orderByComparator.isAscending() ^ previous) {
1264 query.append(WHERE_GREATER_THAN);
1265 }
1266 else {
1267 query.append(WHERE_LESSER_THAN);
1268 }
1269 }
1270 }
1271
1272 query.append(ORDER_BY_CLAUSE);
1273
1274 String[] orderByFields = orderByComparator.getOrderByFields();
1275
1276 for (int i = 0; i < orderByFields.length; i++) {
1277 query.append(_ORDER_BY_ENTITY_ALIAS);
1278 query.append(orderByFields[i]);
1279
1280 if ((i + 1) < orderByFields.length) {
1281 if (orderByComparator.isAscending() ^ previous) {
1282 query.append(ORDER_BY_ASC_HAS_NEXT);
1283 }
1284 else {
1285 query.append(ORDER_BY_DESC_HAS_NEXT);
1286 }
1287 }
1288 else {
1289 if (orderByComparator.isAscending() ^ previous) {
1290 query.append(ORDER_BY_ASC);
1291 }
1292 else {
1293 query.append(ORDER_BY_DESC);
1294 }
1295 }
1296 }
1297 }
1298 else {
1299 query.append(DDLRecordSetModelImpl.ORDER_BY_JPQL);
1300 }
1301
1302 String sql = query.toString();
1303
1304 Query q = session.createQuery(sql);
1305
1306 q.setFirstResult(0);
1307 q.setMaxResults(2);
1308
1309 QueryPos qPos = QueryPos.getInstance(q);
1310
1311 if (bindUuid) {
1312 qPos.add(uuid);
1313 }
1314
1315 qPos.add(companyId);
1316
1317 if (orderByComparator != null) {
1318 Object[] values = orderByComparator.getOrderByConditionValues(ddlRecordSet);
1319
1320 for (Object value : values) {
1321 qPos.add(value);
1322 }
1323 }
1324
1325 List<DDLRecordSet> list = q.list();
1326
1327 if (list.size() == 2) {
1328 return list.get(1);
1329 }
1330 else {
1331 return null;
1332 }
1333 }
1334
1335
1341 @Override
1342 public void removeByUuid_C(String uuid, long companyId) {
1343 for (DDLRecordSet ddlRecordSet : findByUuid_C(uuid, companyId,
1344 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
1345 remove(ddlRecordSet);
1346 }
1347 }
1348
1349
1356 @Override
1357 public int countByUuid_C(String uuid, long companyId) {
1358 FinderPath finderPath = FINDER_PATH_COUNT_BY_UUID_C;
1359
1360 Object[] finderArgs = new Object[] { uuid, companyId };
1361
1362 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
1363 this);
1364
1365 if (count == null) {
1366 StringBundler query = new StringBundler(3);
1367
1368 query.append(_SQL_COUNT_DDLRECORDSET_WHERE);
1369
1370 boolean bindUuid = false;
1371
1372 if (uuid == null) {
1373 query.append(_FINDER_COLUMN_UUID_C_UUID_1);
1374 }
1375 else if (uuid.equals(StringPool.BLANK)) {
1376 query.append(_FINDER_COLUMN_UUID_C_UUID_3);
1377 }
1378 else {
1379 bindUuid = true;
1380
1381 query.append(_FINDER_COLUMN_UUID_C_UUID_2);
1382 }
1383
1384 query.append(_FINDER_COLUMN_UUID_C_COMPANYID_2);
1385
1386 String sql = query.toString();
1387
1388 Session session = null;
1389
1390 try {
1391 session = openSession();
1392
1393 Query q = session.createQuery(sql);
1394
1395 QueryPos qPos = QueryPos.getInstance(q);
1396
1397 if (bindUuid) {
1398 qPos.add(uuid);
1399 }
1400
1401 qPos.add(companyId);
1402
1403 count = (Long)q.uniqueResult();
1404
1405 FinderCacheUtil.putResult(finderPath, finderArgs, count);
1406 }
1407 catch (Exception e) {
1408 FinderCacheUtil.removeResult(finderPath, finderArgs);
1409
1410 throw processException(e);
1411 }
1412 finally {
1413 closeSession(session);
1414 }
1415 }
1416
1417 return count.intValue();
1418 }
1419
1420 private static final String _FINDER_COLUMN_UUID_C_UUID_1 = "ddlRecordSet.uuid IS NULL AND ";
1421 private static final String _FINDER_COLUMN_UUID_C_UUID_2 = "ddlRecordSet.uuid = ? AND ";
1422 private static final String _FINDER_COLUMN_UUID_C_UUID_3 = "(ddlRecordSet.uuid IS NULL OR ddlRecordSet.uuid = '') AND ";
1423 private static final String _FINDER_COLUMN_UUID_C_COMPANYID_2 = "ddlRecordSet.companyId = ?";
1424 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_GROUPID = new FinderPath(DDLRecordSetModelImpl.ENTITY_CACHE_ENABLED,
1425 DDLRecordSetModelImpl.FINDER_CACHE_ENABLED, DDLRecordSetImpl.class,
1426 FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByGroupId",
1427 new String[] {
1428 Long.class.getName(),
1429
1430 Integer.class.getName(), Integer.class.getName(),
1431 OrderByComparator.class.getName()
1432 });
1433 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID =
1434 new FinderPath(DDLRecordSetModelImpl.ENTITY_CACHE_ENABLED,
1435 DDLRecordSetModelImpl.FINDER_CACHE_ENABLED, DDLRecordSetImpl.class,
1436 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByGroupId",
1437 new String[] { Long.class.getName() },
1438 DDLRecordSetModelImpl.GROUPID_COLUMN_BITMASK);
1439 public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(DDLRecordSetModelImpl.ENTITY_CACHE_ENABLED,
1440 DDLRecordSetModelImpl.FINDER_CACHE_ENABLED, Long.class,
1441 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByGroupId",
1442 new String[] { Long.class.getName() });
1443
1444
1450 @Override
1451 public List<DDLRecordSet> findByGroupId(long groupId) {
1452 return findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1453 }
1454
1455
1467 @Override
1468 public List<DDLRecordSet> findByGroupId(long groupId, int start, int end) {
1469 return findByGroupId(groupId, start, end, null);
1470 }
1471
1472
1485 @Override
1486 public List<DDLRecordSet> findByGroupId(long groupId, int start, int end,
1487 OrderByComparator<DDLRecordSet> orderByComparator) {
1488 boolean pagination = true;
1489 FinderPath finderPath = null;
1490 Object[] finderArgs = null;
1491
1492 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
1493 (orderByComparator == null)) {
1494 pagination = false;
1495 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID;
1496 finderArgs = new Object[] { groupId };
1497 }
1498 else {
1499 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_GROUPID;
1500 finderArgs = new Object[] { groupId, start, end, orderByComparator };
1501 }
1502
1503 List<DDLRecordSet> list = (List<DDLRecordSet>)FinderCacheUtil.getResult(finderPath,
1504 finderArgs, this);
1505
1506 if ((list != null) && !list.isEmpty()) {
1507 for (DDLRecordSet ddlRecordSet : list) {
1508 if ((groupId != ddlRecordSet.getGroupId())) {
1509 list = null;
1510
1511 break;
1512 }
1513 }
1514 }
1515
1516 if (list == null) {
1517 StringBundler query = null;
1518
1519 if (orderByComparator != null) {
1520 query = new StringBundler(3 +
1521 (orderByComparator.getOrderByFields().length * 3));
1522 }
1523 else {
1524 query = new StringBundler(3);
1525 }
1526
1527 query.append(_SQL_SELECT_DDLRECORDSET_WHERE);
1528
1529 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1530
1531 if (orderByComparator != null) {
1532 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1533 orderByComparator);
1534 }
1535 else
1536 if (pagination) {
1537 query.append(DDLRecordSetModelImpl.ORDER_BY_JPQL);
1538 }
1539
1540 String sql = query.toString();
1541
1542 Session session = null;
1543
1544 try {
1545 session = openSession();
1546
1547 Query q = session.createQuery(sql);
1548
1549 QueryPos qPos = QueryPos.getInstance(q);
1550
1551 qPos.add(groupId);
1552
1553 if (!pagination) {
1554 list = (List<DDLRecordSet>)QueryUtil.list(q, getDialect(),
1555 start, end, false);
1556
1557 Collections.sort(list);
1558
1559 list = Collections.unmodifiableList(list);
1560 }
1561 else {
1562 list = (List<DDLRecordSet>)QueryUtil.list(q, getDialect(),
1563 start, end);
1564 }
1565
1566 cacheResult(list);
1567
1568 FinderCacheUtil.putResult(finderPath, finderArgs, list);
1569 }
1570 catch (Exception e) {
1571 FinderCacheUtil.removeResult(finderPath, finderArgs);
1572
1573 throw processException(e);
1574 }
1575 finally {
1576 closeSession(session);
1577 }
1578 }
1579
1580 return list;
1581 }
1582
1583
1591 @Override
1592 public DDLRecordSet findByGroupId_First(long groupId,
1593 OrderByComparator<DDLRecordSet> orderByComparator)
1594 throws NoSuchRecordSetException {
1595 DDLRecordSet ddlRecordSet = fetchByGroupId_First(groupId,
1596 orderByComparator);
1597
1598 if (ddlRecordSet != null) {
1599 return ddlRecordSet;
1600 }
1601
1602 StringBundler msg = new StringBundler(4);
1603
1604 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1605
1606 msg.append("groupId=");
1607 msg.append(groupId);
1608
1609 msg.append(StringPool.CLOSE_CURLY_BRACE);
1610
1611 throw new NoSuchRecordSetException(msg.toString());
1612 }
1613
1614
1621 @Override
1622 public DDLRecordSet fetchByGroupId_First(long groupId,
1623 OrderByComparator<DDLRecordSet> orderByComparator) {
1624 List<DDLRecordSet> list = findByGroupId(groupId, 0, 1, orderByComparator);
1625
1626 if (!list.isEmpty()) {
1627 return list.get(0);
1628 }
1629
1630 return null;
1631 }
1632
1633
1641 @Override
1642 public DDLRecordSet findByGroupId_Last(long groupId,
1643 OrderByComparator<DDLRecordSet> orderByComparator)
1644 throws NoSuchRecordSetException {
1645 DDLRecordSet ddlRecordSet = fetchByGroupId_Last(groupId,
1646 orderByComparator);
1647
1648 if (ddlRecordSet != null) {
1649 return ddlRecordSet;
1650 }
1651
1652 StringBundler msg = new StringBundler(4);
1653
1654 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1655
1656 msg.append("groupId=");
1657 msg.append(groupId);
1658
1659 msg.append(StringPool.CLOSE_CURLY_BRACE);
1660
1661 throw new NoSuchRecordSetException(msg.toString());
1662 }
1663
1664
1671 @Override
1672 public DDLRecordSet fetchByGroupId_Last(long groupId,
1673 OrderByComparator<DDLRecordSet> orderByComparator) {
1674 int count = countByGroupId(groupId);
1675
1676 if (count == 0) {
1677 return null;
1678 }
1679
1680 List<DDLRecordSet> list = findByGroupId(groupId, count - 1, count,
1681 orderByComparator);
1682
1683 if (!list.isEmpty()) {
1684 return list.get(0);
1685 }
1686
1687 return null;
1688 }
1689
1690
1699 @Override
1700 public DDLRecordSet[] findByGroupId_PrevAndNext(long recordSetId,
1701 long groupId, OrderByComparator<DDLRecordSet> orderByComparator)
1702 throws NoSuchRecordSetException {
1703 DDLRecordSet ddlRecordSet = findByPrimaryKey(recordSetId);
1704
1705 Session session = null;
1706
1707 try {
1708 session = openSession();
1709
1710 DDLRecordSet[] array = new DDLRecordSetImpl[3];
1711
1712 array[0] = getByGroupId_PrevAndNext(session, ddlRecordSet, groupId,
1713 orderByComparator, true);
1714
1715 array[1] = ddlRecordSet;
1716
1717 array[2] = getByGroupId_PrevAndNext(session, ddlRecordSet, groupId,
1718 orderByComparator, false);
1719
1720 return array;
1721 }
1722 catch (Exception e) {
1723 throw processException(e);
1724 }
1725 finally {
1726 closeSession(session);
1727 }
1728 }
1729
1730 protected DDLRecordSet getByGroupId_PrevAndNext(Session session,
1731 DDLRecordSet ddlRecordSet, long groupId,
1732 OrderByComparator<DDLRecordSet> orderByComparator, boolean previous) {
1733 StringBundler query = null;
1734
1735 if (orderByComparator != null) {
1736 query = new StringBundler(6 +
1737 (orderByComparator.getOrderByFields().length * 6));
1738 }
1739 else {
1740 query = new StringBundler(3);
1741 }
1742
1743 query.append(_SQL_SELECT_DDLRECORDSET_WHERE);
1744
1745 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1746
1747 if (orderByComparator != null) {
1748 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
1749
1750 if (orderByConditionFields.length > 0) {
1751 query.append(WHERE_AND);
1752 }
1753
1754 for (int i = 0; i < orderByConditionFields.length; i++) {
1755 query.append(_ORDER_BY_ENTITY_ALIAS);
1756 query.append(orderByConditionFields[i]);
1757
1758 if ((i + 1) < orderByConditionFields.length) {
1759 if (orderByComparator.isAscending() ^ previous) {
1760 query.append(WHERE_GREATER_THAN_HAS_NEXT);
1761 }
1762 else {
1763 query.append(WHERE_LESSER_THAN_HAS_NEXT);
1764 }
1765 }
1766 else {
1767 if (orderByComparator.isAscending() ^ previous) {
1768 query.append(WHERE_GREATER_THAN);
1769 }
1770 else {
1771 query.append(WHERE_LESSER_THAN);
1772 }
1773 }
1774 }
1775
1776 query.append(ORDER_BY_CLAUSE);
1777
1778 String[] orderByFields = orderByComparator.getOrderByFields();
1779
1780 for (int i = 0; i < orderByFields.length; i++) {
1781 query.append(_ORDER_BY_ENTITY_ALIAS);
1782 query.append(orderByFields[i]);
1783
1784 if ((i + 1) < orderByFields.length) {
1785 if (orderByComparator.isAscending() ^ previous) {
1786 query.append(ORDER_BY_ASC_HAS_NEXT);
1787 }
1788 else {
1789 query.append(ORDER_BY_DESC_HAS_NEXT);
1790 }
1791 }
1792 else {
1793 if (orderByComparator.isAscending() ^ previous) {
1794 query.append(ORDER_BY_ASC);
1795 }
1796 else {
1797 query.append(ORDER_BY_DESC);
1798 }
1799 }
1800 }
1801 }
1802 else {
1803 query.append(DDLRecordSetModelImpl.ORDER_BY_JPQL);
1804 }
1805
1806 String sql = query.toString();
1807
1808 Query q = session.createQuery(sql);
1809
1810 q.setFirstResult(0);
1811 q.setMaxResults(2);
1812
1813 QueryPos qPos = QueryPos.getInstance(q);
1814
1815 qPos.add(groupId);
1816
1817 if (orderByComparator != null) {
1818 Object[] values = orderByComparator.getOrderByConditionValues(ddlRecordSet);
1819
1820 for (Object value : values) {
1821 qPos.add(value);
1822 }
1823 }
1824
1825 List<DDLRecordSet> list = q.list();
1826
1827 if (list.size() == 2) {
1828 return list.get(1);
1829 }
1830 else {
1831 return null;
1832 }
1833 }
1834
1835
1841 @Override
1842 public List<DDLRecordSet> filterFindByGroupId(long groupId) {
1843 return filterFindByGroupId(groupId, QueryUtil.ALL_POS,
1844 QueryUtil.ALL_POS, null);
1845 }
1846
1847
1859 @Override
1860 public List<DDLRecordSet> filterFindByGroupId(long groupId, int start,
1861 int end) {
1862 return filterFindByGroupId(groupId, start, end, null);
1863 }
1864
1865
1878 @Override
1879 public List<DDLRecordSet> filterFindByGroupId(long groupId, int start,
1880 int end, OrderByComparator<DDLRecordSet> orderByComparator) {
1881 if (!InlineSQLHelperUtil.isEnabled(groupId)) {
1882 return findByGroupId(groupId, start, end, orderByComparator);
1883 }
1884
1885 StringBundler query = null;
1886
1887 if (orderByComparator != null) {
1888 query = new StringBundler(3 +
1889 (orderByComparator.getOrderByFields().length * 3));
1890 }
1891 else {
1892 query = new StringBundler(3);
1893 }
1894
1895 if (getDB().isSupportsInlineDistinct()) {
1896 query.append(_FILTER_SQL_SELECT_DDLRECORDSET_WHERE);
1897 }
1898 else {
1899 query.append(_FILTER_SQL_SELECT_DDLRECORDSET_NO_INLINE_DISTINCT_WHERE_1);
1900 }
1901
1902 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1903
1904 if (!getDB().isSupportsInlineDistinct()) {
1905 query.append(_FILTER_SQL_SELECT_DDLRECORDSET_NO_INLINE_DISTINCT_WHERE_2);
1906 }
1907
1908 if (orderByComparator != null) {
1909 if (getDB().isSupportsInlineDistinct()) {
1910 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1911 orderByComparator, true);
1912 }
1913 else {
1914 appendOrderByComparator(query, _ORDER_BY_ENTITY_TABLE,
1915 orderByComparator, true);
1916 }
1917 }
1918 else {
1919 if (getDB().isSupportsInlineDistinct()) {
1920 query.append(DDLRecordSetModelImpl.ORDER_BY_JPQL);
1921 }
1922 else {
1923 query.append(DDLRecordSetModelImpl.ORDER_BY_SQL);
1924 }
1925 }
1926
1927 String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
1928 DDLRecordSet.class.getName(),
1929 _FILTER_ENTITY_TABLE_FILTER_PK_COLUMN, groupId);
1930
1931 Session session = null;
1932
1933 try {
1934 session = openSession();
1935
1936 SQLQuery q = session.createSynchronizedSQLQuery(sql);
1937
1938 if (getDB().isSupportsInlineDistinct()) {
1939 q.addEntity(_FILTER_ENTITY_ALIAS, DDLRecordSetImpl.class);
1940 }
1941 else {
1942 q.addEntity(_FILTER_ENTITY_TABLE, DDLRecordSetImpl.class);
1943 }
1944
1945 QueryPos qPos = QueryPos.getInstance(q);
1946
1947 qPos.add(groupId);
1948
1949 return (List<DDLRecordSet>)QueryUtil.list(q, getDialect(), start,
1950 end);
1951 }
1952 catch (Exception e) {
1953 throw processException(e);
1954 }
1955 finally {
1956 closeSession(session);
1957 }
1958 }
1959
1960
1969 @Override
1970 public DDLRecordSet[] filterFindByGroupId_PrevAndNext(long recordSetId,
1971 long groupId, OrderByComparator<DDLRecordSet> orderByComparator)
1972 throws NoSuchRecordSetException {
1973 if (!InlineSQLHelperUtil.isEnabled(groupId)) {
1974 return findByGroupId_PrevAndNext(recordSetId, groupId,
1975 orderByComparator);
1976 }
1977
1978 DDLRecordSet ddlRecordSet = findByPrimaryKey(recordSetId);
1979
1980 Session session = null;
1981
1982 try {
1983 session = openSession();
1984
1985 DDLRecordSet[] array = new DDLRecordSetImpl[3];
1986
1987 array[0] = filterGetByGroupId_PrevAndNext(session, ddlRecordSet,
1988 groupId, orderByComparator, true);
1989
1990 array[1] = ddlRecordSet;
1991
1992 array[2] = filterGetByGroupId_PrevAndNext(session, ddlRecordSet,
1993 groupId, orderByComparator, false);
1994
1995 return array;
1996 }
1997 catch (Exception e) {
1998 throw processException(e);
1999 }
2000 finally {
2001 closeSession(session);
2002 }
2003 }
2004
2005 protected DDLRecordSet filterGetByGroupId_PrevAndNext(Session session,
2006 DDLRecordSet ddlRecordSet, long groupId,
2007 OrderByComparator<DDLRecordSet> orderByComparator, boolean previous) {
2008 StringBundler query = null;
2009
2010 if (orderByComparator != null) {
2011 query = new StringBundler(6 +
2012 (orderByComparator.getOrderByFields().length * 6));
2013 }
2014 else {
2015 query = new StringBundler(3);
2016 }
2017
2018 if (getDB().isSupportsInlineDistinct()) {
2019 query.append(_FILTER_SQL_SELECT_DDLRECORDSET_WHERE);
2020 }
2021 else {
2022 query.append(_FILTER_SQL_SELECT_DDLRECORDSET_NO_INLINE_DISTINCT_WHERE_1);
2023 }
2024
2025 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
2026
2027 if (!getDB().isSupportsInlineDistinct()) {
2028 query.append(_FILTER_SQL_SELECT_DDLRECORDSET_NO_INLINE_DISTINCT_WHERE_2);
2029 }
2030
2031 if (orderByComparator != null) {
2032 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
2033
2034 if (orderByConditionFields.length > 0) {
2035 query.append(WHERE_AND);
2036 }
2037
2038 for (int i = 0; i < orderByConditionFields.length; i++) {
2039 if (getDB().isSupportsInlineDistinct()) {
2040 query.append(_ORDER_BY_ENTITY_ALIAS);
2041 }
2042 else {
2043 query.append(_ORDER_BY_ENTITY_TABLE);
2044 }
2045
2046 query.append(orderByConditionFields[i]);
2047
2048 if ((i + 1) < orderByConditionFields.length) {
2049 if (orderByComparator.isAscending() ^ previous) {
2050 query.append(WHERE_GREATER_THAN_HAS_NEXT);
2051 }
2052 else {
2053 query.append(WHERE_LESSER_THAN_HAS_NEXT);
2054 }
2055 }
2056 else {
2057 if (orderByComparator.isAscending() ^ previous) {
2058 query.append(WHERE_GREATER_THAN);
2059 }
2060 else {
2061 query.append(WHERE_LESSER_THAN);
2062 }
2063 }
2064 }
2065
2066 query.append(ORDER_BY_CLAUSE);
2067
2068 String[] orderByFields = orderByComparator.getOrderByFields();
2069
2070 for (int i = 0; i < orderByFields.length; i++) {
2071 if (getDB().isSupportsInlineDistinct()) {
2072 query.append(_ORDER_BY_ENTITY_ALIAS);
2073 }
2074 else {
2075 query.append(_ORDER_BY_ENTITY_TABLE);
2076 }
2077
2078 query.append(orderByFields[i]);
2079
2080 if ((i + 1) < orderByFields.length) {
2081 if (orderByComparator.isAscending() ^ previous) {
2082 query.append(ORDER_BY_ASC_HAS_NEXT);
2083 }
2084 else {
2085 query.append(ORDER_BY_DESC_HAS_NEXT);
2086 }
2087 }
2088 else {
2089 if (orderByComparator.isAscending() ^ previous) {
2090 query.append(ORDER_BY_ASC);
2091 }
2092 else {
2093 query.append(ORDER_BY_DESC);
2094 }
2095 }
2096 }
2097 }
2098 else {
2099 if (getDB().isSupportsInlineDistinct()) {
2100 query.append(DDLRecordSetModelImpl.ORDER_BY_JPQL);
2101 }
2102 else {
2103 query.append(DDLRecordSetModelImpl.ORDER_BY_SQL);
2104 }
2105 }
2106
2107 String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
2108 DDLRecordSet.class.getName(),
2109 _FILTER_ENTITY_TABLE_FILTER_PK_COLUMN, groupId);
2110
2111 SQLQuery q = session.createSynchronizedSQLQuery(sql);
2112
2113 q.setFirstResult(0);
2114 q.setMaxResults(2);
2115
2116 if (getDB().isSupportsInlineDistinct()) {
2117 q.addEntity(_FILTER_ENTITY_ALIAS, DDLRecordSetImpl.class);
2118 }
2119 else {
2120 q.addEntity(_FILTER_ENTITY_TABLE, DDLRecordSetImpl.class);
2121 }
2122
2123 QueryPos qPos = QueryPos.getInstance(q);
2124
2125 qPos.add(groupId);
2126
2127 if (orderByComparator != null) {
2128 Object[] values = orderByComparator.getOrderByConditionValues(ddlRecordSet);
2129
2130 for (Object value : values) {
2131 qPos.add(value);
2132 }
2133 }
2134
2135 List<DDLRecordSet> list = q.list();
2136
2137 if (list.size() == 2) {
2138 return list.get(1);
2139 }
2140 else {
2141 return null;
2142 }
2143 }
2144
2145
2150 @Override
2151 public void removeByGroupId(long groupId) {
2152 for (DDLRecordSet ddlRecordSet : findByGroupId(groupId,
2153 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
2154 remove(ddlRecordSet);
2155 }
2156 }
2157
2158
2164 @Override
2165 public int countByGroupId(long groupId) {
2166 FinderPath finderPath = FINDER_PATH_COUNT_BY_GROUPID;
2167
2168 Object[] finderArgs = new Object[] { groupId };
2169
2170 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
2171 this);
2172
2173 if (count == null) {
2174 StringBundler query = new StringBundler(2);
2175
2176 query.append(_SQL_COUNT_DDLRECORDSET_WHERE);
2177
2178 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
2179
2180 String sql = query.toString();
2181
2182 Session session = null;
2183
2184 try {
2185 session = openSession();
2186
2187 Query q = session.createQuery(sql);
2188
2189 QueryPos qPos = QueryPos.getInstance(q);
2190
2191 qPos.add(groupId);
2192
2193 count = (Long)q.uniqueResult();
2194
2195 FinderCacheUtil.putResult(finderPath, finderArgs, count);
2196 }
2197 catch (Exception e) {
2198 FinderCacheUtil.removeResult(finderPath, finderArgs);
2199
2200 throw processException(e);
2201 }
2202 finally {
2203 closeSession(session);
2204 }
2205 }
2206
2207 return count.intValue();
2208 }
2209
2210
2216 @Override
2217 public int filterCountByGroupId(long groupId) {
2218 if (!InlineSQLHelperUtil.isEnabled(groupId)) {
2219 return countByGroupId(groupId);
2220 }
2221
2222 StringBundler query = new StringBundler(2);
2223
2224 query.append(_FILTER_SQL_COUNT_DDLRECORDSET_WHERE);
2225
2226 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
2227
2228 String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
2229 DDLRecordSet.class.getName(),
2230 _FILTER_ENTITY_TABLE_FILTER_PK_COLUMN, groupId);
2231
2232 Session session = null;
2233
2234 try {
2235 session = openSession();
2236
2237 SQLQuery q = session.createSynchronizedSQLQuery(sql);
2238
2239 q.addScalar(COUNT_COLUMN_NAME,
2240 com.liferay.portal.kernel.dao.orm.Type.LONG);
2241
2242 QueryPos qPos = QueryPos.getInstance(q);
2243
2244 qPos.add(groupId);
2245
2246 Long count = (Long)q.uniqueResult();
2247
2248 return count.intValue();
2249 }
2250 catch (Exception e) {
2251 throw processException(e);
2252 }
2253 finally {
2254 closeSession(session);
2255 }
2256 }
2257
2258 private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "ddlRecordSet.groupId = ?";
2259 public static final FinderPath FINDER_PATH_FETCH_BY_G_R = new FinderPath(DDLRecordSetModelImpl.ENTITY_CACHE_ENABLED,
2260 DDLRecordSetModelImpl.FINDER_CACHE_ENABLED, DDLRecordSetImpl.class,
2261 FINDER_CLASS_NAME_ENTITY, "fetchByG_R",
2262 new String[] { Long.class.getName(), String.class.getName() },
2263 DDLRecordSetModelImpl.GROUPID_COLUMN_BITMASK |
2264 DDLRecordSetModelImpl.RECORDSETKEY_COLUMN_BITMASK);
2265 public static final FinderPath FINDER_PATH_COUNT_BY_G_R = new FinderPath(DDLRecordSetModelImpl.ENTITY_CACHE_ENABLED,
2266 DDLRecordSetModelImpl.FINDER_CACHE_ENABLED, Long.class,
2267 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByG_R",
2268 new String[] { Long.class.getName(), String.class.getName() });
2269
2270
2278 @Override
2279 public DDLRecordSet findByG_R(long groupId, String recordSetKey)
2280 throws NoSuchRecordSetException {
2281 DDLRecordSet ddlRecordSet = fetchByG_R(groupId, recordSetKey);
2282
2283 if (ddlRecordSet == null) {
2284 StringBundler msg = new StringBundler(6);
2285
2286 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2287
2288 msg.append("groupId=");
2289 msg.append(groupId);
2290
2291 msg.append(", recordSetKey=");
2292 msg.append(recordSetKey);
2293
2294 msg.append(StringPool.CLOSE_CURLY_BRACE);
2295
2296 if (_log.isWarnEnabled()) {
2297 _log.warn(msg.toString());
2298 }
2299
2300 throw new NoSuchRecordSetException(msg.toString());
2301 }
2302
2303 return ddlRecordSet;
2304 }
2305
2306
2313 @Override
2314 public DDLRecordSet fetchByG_R(long groupId, String recordSetKey) {
2315 return fetchByG_R(groupId, recordSetKey, true);
2316 }
2317
2318
2326 @Override
2327 public DDLRecordSet fetchByG_R(long groupId, String recordSetKey,
2328 boolean retrieveFromCache) {
2329 Object[] finderArgs = new Object[] { groupId, recordSetKey };
2330
2331 Object result = null;
2332
2333 if (retrieveFromCache) {
2334 result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_G_R,
2335 finderArgs, this);
2336 }
2337
2338 if (result instanceof DDLRecordSet) {
2339 DDLRecordSet ddlRecordSet = (DDLRecordSet)result;
2340
2341 if ((groupId != ddlRecordSet.getGroupId()) ||
2342 !Validator.equals(recordSetKey,
2343 ddlRecordSet.getRecordSetKey())) {
2344 result = null;
2345 }
2346 }
2347
2348 if (result == null) {
2349 StringBundler query = new StringBundler(4);
2350
2351 query.append(_SQL_SELECT_DDLRECORDSET_WHERE);
2352
2353 query.append(_FINDER_COLUMN_G_R_GROUPID_2);
2354
2355 boolean bindRecordSetKey = false;
2356
2357 if (recordSetKey == null) {
2358 query.append(_FINDER_COLUMN_G_R_RECORDSETKEY_1);
2359 }
2360 else if (recordSetKey.equals(StringPool.BLANK)) {
2361 query.append(_FINDER_COLUMN_G_R_RECORDSETKEY_3);
2362 }
2363 else {
2364 bindRecordSetKey = true;
2365
2366 query.append(_FINDER_COLUMN_G_R_RECORDSETKEY_2);
2367 }
2368
2369 String sql = query.toString();
2370
2371 Session session = null;
2372
2373 try {
2374 session = openSession();
2375
2376 Query q = session.createQuery(sql);
2377
2378 QueryPos qPos = QueryPos.getInstance(q);
2379
2380 qPos.add(groupId);
2381
2382 if (bindRecordSetKey) {
2383 qPos.add(recordSetKey);
2384 }
2385
2386 List<DDLRecordSet> list = q.list();
2387
2388 if (list.isEmpty()) {
2389 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_R,
2390 finderArgs, list);
2391 }
2392 else {
2393 DDLRecordSet ddlRecordSet = list.get(0);
2394
2395 result = ddlRecordSet;
2396
2397 cacheResult(ddlRecordSet);
2398
2399 if ((ddlRecordSet.getGroupId() != groupId) ||
2400 (ddlRecordSet.getRecordSetKey() == null) ||
2401 !ddlRecordSet.getRecordSetKey().equals(recordSetKey)) {
2402 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_R,
2403 finderArgs, ddlRecordSet);
2404 }
2405 }
2406 }
2407 catch (Exception e) {
2408 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_R,
2409 finderArgs);
2410
2411 throw processException(e);
2412 }
2413 finally {
2414 closeSession(session);
2415 }
2416 }
2417
2418 if (result instanceof List<?>) {
2419 return null;
2420 }
2421 else {
2422 return (DDLRecordSet)result;
2423 }
2424 }
2425
2426
2433 @Override
2434 public DDLRecordSet removeByG_R(long groupId, String recordSetKey)
2435 throws NoSuchRecordSetException {
2436 DDLRecordSet ddlRecordSet = findByG_R(groupId, recordSetKey);
2437
2438 return remove(ddlRecordSet);
2439 }
2440
2441
2448 @Override
2449 public int countByG_R(long groupId, String recordSetKey) {
2450 FinderPath finderPath = FINDER_PATH_COUNT_BY_G_R;
2451
2452 Object[] finderArgs = new Object[] { groupId, recordSetKey };
2453
2454 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
2455 this);
2456
2457 if (count == null) {
2458 StringBundler query = new StringBundler(3);
2459
2460 query.append(_SQL_COUNT_DDLRECORDSET_WHERE);
2461
2462 query.append(_FINDER_COLUMN_G_R_GROUPID_2);
2463
2464 boolean bindRecordSetKey = false;
2465
2466 if (recordSetKey == null) {
2467 query.append(_FINDER_COLUMN_G_R_RECORDSETKEY_1);
2468 }
2469 else if (recordSetKey.equals(StringPool.BLANK)) {
2470 query.append(_FINDER_COLUMN_G_R_RECORDSETKEY_3);
2471 }
2472 else {
2473 bindRecordSetKey = true;
2474
2475 query.append(_FINDER_COLUMN_G_R_RECORDSETKEY_2);
2476 }
2477
2478 String sql = query.toString();
2479
2480 Session session = null;
2481
2482 try {
2483 session = openSession();
2484
2485 Query q = session.createQuery(sql);
2486
2487 QueryPos qPos = QueryPos.getInstance(q);
2488
2489 qPos.add(groupId);
2490
2491 if (bindRecordSetKey) {
2492 qPos.add(recordSetKey);
2493 }
2494
2495 count = (Long)q.uniqueResult();
2496
2497 FinderCacheUtil.putResult(finderPath, finderArgs, count);
2498 }
2499 catch (Exception e) {
2500 FinderCacheUtil.removeResult(finderPath, finderArgs);
2501
2502 throw processException(e);
2503 }
2504 finally {
2505 closeSession(session);
2506 }
2507 }
2508
2509 return count.intValue();
2510 }
2511
2512 private static final String _FINDER_COLUMN_G_R_GROUPID_2 = "ddlRecordSet.groupId = ? AND ";
2513 private static final String _FINDER_COLUMN_G_R_RECORDSETKEY_1 = "ddlRecordSet.recordSetKey IS NULL";
2514 private static final String _FINDER_COLUMN_G_R_RECORDSETKEY_2 = "ddlRecordSet.recordSetKey = ?";
2515 private static final String _FINDER_COLUMN_G_R_RECORDSETKEY_3 = "(ddlRecordSet.recordSetKey IS NULL OR ddlRecordSet.recordSetKey = '')";
2516
2517 public DDLRecordSetPersistenceImpl() {
2518 setModelClass(DDLRecordSet.class);
2519 }
2520
2521
2526 @Override
2527 public void cacheResult(DDLRecordSet ddlRecordSet) {
2528 EntityCacheUtil.putResult(DDLRecordSetModelImpl.ENTITY_CACHE_ENABLED,
2529 DDLRecordSetImpl.class, ddlRecordSet.getPrimaryKey(), ddlRecordSet);
2530
2531 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
2532 new Object[] { ddlRecordSet.getUuid(), ddlRecordSet.getGroupId() },
2533 ddlRecordSet);
2534
2535 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_R,
2536 new Object[] {
2537 ddlRecordSet.getGroupId(), ddlRecordSet.getRecordSetKey()
2538 }, ddlRecordSet);
2539
2540 ddlRecordSet.resetOriginalValues();
2541 }
2542
2543
2548 @Override
2549 public void cacheResult(List<DDLRecordSet> ddlRecordSets) {
2550 for (DDLRecordSet ddlRecordSet : ddlRecordSets) {
2551 if (EntityCacheUtil.getResult(
2552 DDLRecordSetModelImpl.ENTITY_CACHE_ENABLED,
2553 DDLRecordSetImpl.class, ddlRecordSet.getPrimaryKey()) == null) {
2554 cacheResult(ddlRecordSet);
2555 }
2556 else {
2557 ddlRecordSet.resetOriginalValues();
2558 }
2559 }
2560 }
2561
2562
2569 @Override
2570 public void clearCache() {
2571 if (_HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE) {
2572 CacheRegistryUtil.clear(DDLRecordSetImpl.class.getName());
2573 }
2574
2575 EntityCacheUtil.clearCache(DDLRecordSetImpl.class);
2576
2577 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
2578 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
2579 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
2580 }
2581
2582
2589 @Override
2590 public void clearCache(DDLRecordSet ddlRecordSet) {
2591 EntityCacheUtil.removeResult(DDLRecordSetModelImpl.ENTITY_CACHE_ENABLED,
2592 DDLRecordSetImpl.class, ddlRecordSet.getPrimaryKey());
2593
2594 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
2595 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
2596
2597 clearUniqueFindersCache(ddlRecordSet);
2598 }
2599
2600 @Override
2601 public void clearCache(List<DDLRecordSet> ddlRecordSets) {
2602 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
2603 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
2604
2605 for (DDLRecordSet ddlRecordSet : ddlRecordSets) {
2606 EntityCacheUtil.removeResult(DDLRecordSetModelImpl.ENTITY_CACHE_ENABLED,
2607 DDLRecordSetImpl.class, ddlRecordSet.getPrimaryKey());
2608
2609 clearUniqueFindersCache(ddlRecordSet);
2610 }
2611 }
2612
2613 protected void cacheUniqueFindersCache(DDLRecordSet ddlRecordSet) {
2614 if (ddlRecordSet.isNew()) {
2615 Object[] args = new Object[] {
2616 ddlRecordSet.getUuid(), ddlRecordSet.getGroupId()
2617 };
2618
2619 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID_G, args,
2620 Long.valueOf(1));
2621 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G, args,
2622 ddlRecordSet);
2623
2624 args = new Object[] {
2625 ddlRecordSet.getGroupId(), ddlRecordSet.getRecordSetKey()
2626 };
2627
2628 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_R, args,
2629 Long.valueOf(1));
2630 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_R, args,
2631 ddlRecordSet);
2632 }
2633 else {
2634 DDLRecordSetModelImpl ddlRecordSetModelImpl = (DDLRecordSetModelImpl)ddlRecordSet;
2635
2636 if ((ddlRecordSetModelImpl.getColumnBitmask() &
2637 FINDER_PATH_FETCH_BY_UUID_G.getColumnBitmask()) != 0) {
2638 Object[] args = new Object[] {
2639 ddlRecordSet.getUuid(), ddlRecordSet.getGroupId()
2640 };
2641
2642 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID_G, args,
2643 Long.valueOf(1));
2644 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G, args,
2645 ddlRecordSet);
2646 }
2647
2648 if ((ddlRecordSetModelImpl.getColumnBitmask() &
2649 FINDER_PATH_FETCH_BY_G_R.getColumnBitmask()) != 0) {
2650 Object[] args = new Object[] {
2651 ddlRecordSet.getGroupId(),
2652 ddlRecordSet.getRecordSetKey()
2653 };
2654
2655 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_R, args,
2656 Long.valueOf(1));
2657 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_R, args,
2658 ddlRecordSet);
2659 }
2660 }
2661 }
2662
2663 protected void clearUniqueFindersCache(DDLRecordSet ddlRecordSet) {
2664 DDLRecordSetModelImpl ddlRecordSetModelImpl = (DDLRecordSetModelImpl)ddlRecordSet;
2665
2666 Object[] args = new Object[] {
2667 ddlRecordSet.getUuid(), ddlRecordSet.getGroupId()
2668 };
2669
2670 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID_G, args);
2671 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G, args);
2672
2673 if ((ddlRecordSetModelImpl.getColumnBitmask() &
2674 FINDER_PATH_FETCH_BY_UUID_G.getColumnBitmask()) != 0) {
2675 args = new Object[] {
2676 ddlRecordSetModelImpl.getOriginalUuid(),
2677 ddlRecordSetModelImpl.getOriginalGroupId()
2678 };
2679
2680 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID_G, args);
2681 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G, args);
2682 }
2683
2684 args = new Object[] {
2685 ddlRecordSet.getGroupId(), ddlRecordSet.getRecordSetKey()
2686 };
2687
2688 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_G_R, args);
2689 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_R, args);
2690
2691 if ((ddlRecordSetModelImpl.getColumnBitmask() &
2692 FINDER_PATH_FETCH_BY_G_R.getColumnBitmask()) != 0) {
2693 args = new Object[] {
2694 ddlRecordSetModelImpl.getOriginalGroupId(),
2695 ddlRecordSetModelImpl.getOriginalRecordSetKey()
2696 };
2697
2698 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_G_R, args);
2699 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_R, args);
2700 }
2701 }
2702
2703
2709 @Override
2710 public DDLRecordSet create(long recordSetId) {
2711 DDLRecordSet ddlRecordSet = new DDLRecordSetImpl();
2712
2713 ddlRecordSet.setNew(true);
2714 ddlRecordSet.setPrimaryKey(recordSetId);
2715
2716 String uuid = PortalUUIDUtil.generate();
2717
2718 ddlRecordSet.setUuid(uuid);
2719
2720 return ddlRecordSet;
2721 }
2722
2723
2730 @Override
2731 public DDLRecordSet remove(long recordSetId)
2732 throws NoSuchRecordSetException {
2733 return remove((Serializable)recordSetId);
2734 }
2735
2736
2743 @Override
2744 public DDLRecordSet remove(Serializable primaryKey)
2745 throws NoSuchRecordSetException {
2746 Session session = null;
2747
2748 try {
2749 session = openSession();
2750
2751 DDLRecordSet ddlRecordSet = (DDLRecordSet)session.get(DDLRecordSetImpl.class,
2752 primaryKey);
2753
2754 if (ddlRecordSet == null) {
2755 if (_log.isWarnEnabled()) {
2756 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey);
2757 }
2758
2759 throw new NoSuchRecordSetException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
2760 primaryKey);
2761 }
2762
2763 return remove(ddlRecordSet);
2764 }
2765 catch (NoSuchRecordSetException nsee) {
2766 throw nsee;
2767 }
2768 catch (Exception e) {
2769 throw processException(e);
2770 }
2771 finally {
2772 closeSession(session);
2773 }
2774 }
2775
2776 @Override
2777 protected DDLRecordSet removeImpl(DDLRecordSet ddlRecordSet) {
2778 ddlRecordSet = toUnwrappedModel(ddlRecordSet);
2779
2780 Session session = null;
2781
2782 try {
2783 session = openSession();
2784
2785 if (!session.contains(ddlRecordSet)) {
2786 ddlRecordSet = (DDLRecordSet)session.get(DDLRecordSetImpl.class,
2787 ddlRecordSet.getPrimaryKeyObj());
2788 }
2789
2790 if (ddlRecordSet != null) {
2791 session.delete(ddlRecordSet);
2792 }
2793 }
2794 catch (Exception e) {
2795 throw processException(e);
2796 }
2797 finally {
2798 closeSession(session);
2799 }
2800
2801 if (ddlRecordSet != null) {
2802 clearCache(ddlRecordSet);
2803 }
2804
2805 return ddlRecordSet;
2806 }
2807
2808 @Override
2809 public DDLRecordSet updateImpl(
2810 com.liferay.portlet.dynamicdatalists.model.DDLRecordSet ddlRecordSet) {
2811 ddlRecordSet = toUnwrappedModel(ddlRecordSet);
2812
2813 boolean isNew = ddlRecordSet.isNew();
2814
2815 DDLRecordSetModelImpl ddlRecordSetModelImpl = (DDLRecordSetModelImpl)ddlRecordSet;
2816
2817 if (Validator.isNull(ddlRecordSet.getUuid())) {
2818 String uuid = PortalUUIDUtil.generate();
2819
2820 ddlRecordSet.setUuid(uuid);
2821 }
2822
2823 Session session = null;
2824
2825 try {
2826 session = openSession();
2827
2828 if (ddlRecordSet.isNew()) {
2829 session.save(ddlRecordSet);
2830
2831 ddlRecordSet.setNew(false);
2832 }
2833 else {
2834 session.merge(ddlRecordSet);
2835 }
2836 }
2837 catch (Exception e) {
2838 throw processException(e);
2839 }
2840 finally {
2841 closeSession(session);
2842 }
2843
2844 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
2845
2846 if (isNew || !DDLRecordSetModelImpl.COLUMN_BITMASK_ENABLED) {
2847 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
2848 }
2849
2850 else {
2851 if ((ddlRecordSetModelImpl.getColumnBitmask() &
2852 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID.getColumnBitmask()) != 0) {
2853 Object[] args = new Object[] {
2854 ddlRecordSetModelImpl.getOriginalUuid()
2855 };
2856
2857 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID, args);
2858 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID,
2859 args);
2860
2861 args = new Object[] { ddlRecordSetModelImpl.getUuid() };
2862
2863 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID, args);
2864 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID,
2865 args);
2866 }
2867
2868 if ((ddlRecordSetModelImpl.getColumnBitmask() &
2869 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C.getColumnBitmask()) != 0) {
2870 Object[] args = new Object[] {
2871 ddlRecordSetModelImpl.getOriginalUuid(),
2872 ddlRecordSetModelImpl.getOriginalCompanyId()
2873 };
2874
2875 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID_C, args);
2876 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C,
2877 args);
2878
2879 args = new Object[] {
2880 ddlRecordSetModelImpl.getUuid(),
2881 ddlRecordSetModelImpl.getCompanyId()
2882 };
2883
2884 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID_C, args);
2885 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C,
2886 args);
2887 }
2888
2889 if ((ddlRecordSetModelImpl.getColumnBitmask() &
2890 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID.getColumnBitmask()) != 0) {
2891 Object[] args = new Object[] {
2892 ddlRecordSetModelImpl.getOriginalGroupId()
2893 };
2894
2895 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_GROUPID, args);
2896 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID,
2897 args);
2898
2899 args = new Object[] { ddlRecordSetModelImpl.getGroupId() };
2900
2901 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_GROUPID, args);
2902 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID,
2903 args);
2904 }
2905 }
2906
2907 EntityCacheUtil.putResult(DDLRecordSetModelImpl.ENTITY_CACHE_ENABLED,
2908 DDLRecordSetImpl.class, ddlRecordSet.getPrimaryKey(), ddlRecordSet,
2909 false);
2910
2911 clearUniqueFindersCache(ddlRecordSet);
2912 cacheUniqueFindersCache(ddlRecordSet);
2913
2914 ddlRecordSet.resetOriginalValues();
2915
2916 return ddlRecordSet;
2917 }
2918
2919 protected DDLRecordSet toUnwrappedModel(DDLRecordSet ddlRecordSet) {
2920 if (ddlRecordSet instanceof DDLRecordSetImpl) {
2921 return ddlRecordSet;
2922 }
2923
2924 DDLRecordSetImpl ddlRecordSetImpl = new DDLRecordSetImpl();
2925
2926 ddlRecordSetImpl.setNew(ddlRecordSet.isNew());
2927 ddlRecordSetImpl.setPrimaryKey(ddlRecordSet.getPrimaryKey());
2928
2929 ddlRecordSetImpl.setUuid(ddlRecordSet.getUuid());
2930 ddlRecordSetImpl.setRecordSetId(ddlRecordSet.getRecordSetId());
2931 ddlRecordSetImpl.setGroupId(ddlRecordSet.getGroupId());
2932 ddlRecordSetImpl.setCompanyId(ddlRecordSet.getCompanyId());
2933 ddlRecordSetImpl.setUserId(ddlRecordSet.getUserId());
2934 ddlRecordSetImpl.setUserName(ddlRecordSet.getUserName());
2935 ddlRecordSetImpl.setCreateDate(ddlRecordSet.getCreateDate());
2936 ddlRecordSetImpl.setModifiedDate(ddlRecordSet.getModifiedDate());
2937 ddlRecordSetImpl.setDDMStructureId(ddlRecordSet.getDDMStructureId());
2938 ddlRecordSetImpl.setRecordSetKey(ddlRecordSet.getRecordSetKey());
2939 ddlRecordSetImpl.setName(ddlRecordSet.getName());
2940 ddlRecordSetImpl.setDescription(ddlRecordSet.getDescription());
2941 ddlRecordSetImpl.setMinDisplayRows(ddlRecordSet.getMinDisplayRows());
2942 ddlRecordSetImpl.setScope(ddlRecordSet.getScope());
2943
2944 return ddlRecordSetImpl;
2945 }
2946
2947
2954 @Override
2955 public DDLRecordSet findByPrimaryKey(Serializable primaryKey)
2956 throws NoSuchRecordSetException {
2957 DDLRecordSet ddlRecordSet = fetchByPrimaryKey(primaryKey);
2958
2959 if (ddlRecordSet == null) {
2960 if (_log.isWarnEnabled()) {
2961 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey);
2962 }
2963
2964 throw new NoSuchRecordSetException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
2965 primaryKey);
2966 }
2967
2968 return ddlRecordSet;
2969 }
2970
2971
2978 @Override
2979 public DDLRecordSet findByPrimaryKey(long recordSetId)
2980 throws NoSuchRecordSetException {
2981 return findByPrimaryKey((Serializable)recordSetId);
2982 }
2983
2984
2990 @Override
2991 public DDLRecordSet fetchByPrimaryKey(Serializable primaryKey) {
2992 DDLRecordSet ddlRecordSet = (DDLRecordSet)EntityCacheUtil.getResult(DDLRecordSetModelImpl.ENTITY_CACHE_ENABLED,
2993 DDLRecordSetImpl.class, primaryKey);
2994
2995 if (ddlRecordSet == _nullDDLRecordSet) {
2996 return null;
2997 }
2998
2999 if (ddlRecordSet == null) {
3000 Session session = null;
3001
3002 try {
3003 session = openSession();
3004
3005 ddlRecordSet = (DDLRecordSet)session.get(DDLRecordSetImpl.class,
3006 primaryKey);
3007
3008 if (ddlRecordSet != null) {
3009 cacheResult(ddlRecordSet);
3010 }
3011 else {
3012 EntityCacheUtil.putResult(DDLRecordSetModelImpl.ENTITY_CACHE_ENABLED,
3013 DDLRecordSetImpl.class, primaryKey, _nullDDLRecordSet);
3014 }
3015 }
3016 catch (Exception e) {
3017 EntityCacheUtil.removeResult(DDLRecordSetModelImpl.ENTITY_CACHE_ENABLED,
3018 DDLRecordSetImpl.class, primaryKey);
3019
3020 throw processException(e);
3021 }
3022 finally {
3023 closeSession(session);
3024 }
3025 }
3026
3027 return ddlRecordSet;
3028 }
3029
3030
3036 @Override
3037 public DDLRecordSet fetchByPrimaryKey(long recordSetId) {
3038 return fetchByPrimaryKey((Serializable)recordSetId);
3039 }
3040
3041 @Override
3042 public Map<Serializable, DDLRecordSet> fetchByPrimaryKeys(
3043 Set<Serializable> primaryKeys) {
3044 if (primaryKeys.isEmpty()) {
3045 return Collections.emptyMap();
3046 }
3047
3048 Map<Serializable, DDLRecordSet> map = new HashMap<Serializable, DDLRecordSet>();
3049
3050 if (primaryKeys.size() == 1) {
3051 Iterator<Serializable> iterator = primaryKeys.iterator();
3052
3053 Serializable primaryKey = iterator.next();
3054
3055 DDLRecordSet ddlRecordSet = fetchByPrimaryKey(primaryKey);
3056
3057 if (ddlRecordSet != null) {
3058 map.put(primaryKey, ddlRecordSet);
3059 }
3060
3061 return map;
3062 }
3063
3064 Set<Serializable> uncachedPrimaryKeys = null;
3065
3066 for (Serializable primaryKey : primaryKeys) {
3067 DDLRecordSet ddlRecordSet = (DDLRecordSet)EntityCacheUtil.getResult(DDLRecordSetModelImpl.ENTITY_CACHE_ENABLED,
3068 DDLRecordSetImpl.class, primaryKey);
3069
3070 if (ddlRecordSet == null) {
3071 if (uncachedPrimaryKeys == null) {
3072 uncachedPrimaryKeys = new HashSet<Serializable>();
3073 }
3074
3075 uncachedPrimaryKeys.add(primaryKey);
3076 }
3077 else {
3078 map.put(primaryKey, ddlRecordSet);
3079 }
3080 }
3081
3082 if (uncachedPrimaryKeys == null) {
3083 return map;
3084 }
3085
3086 StringBundler query = new StringBundler((uncachedPrimaryKeys.size() * 2) +
3087 1);
3088
3089 query.append(_SQL_SELECT_DDLRECORDSET_WHERE_PKS_IN);
3090
3091 for (Serializable primaryKey : uncachedPrimaryKeys) {
3092 query.append(String.valueOf(primaryKey));
3093
3094 query.append(StringPool.COMMA);
3095 }
3096
3097 query.setIndex(query.index() - 1);
3098
3099 query.append(StringPool.CLOSE_PARENTHESIS);
3100
3101 String sql = query.toString();
3102
3103 Session session = null;
3104
3105 try {
3106 session = openSession();
3107
3108 Query q = session.createQuery(sql);
3109
3110 for (DDLRecordSet ddlRecordSet : (List<DDLRecordSet>)q.list()) {
3111 map.put(ddlRecordSet.getPrimaryKeyObj(), ddlRecordSet);
3112
3113 cacheResult(ddlRecordSet);
3114
3115 uncachedPrimaryKeys.remove(ddlRecordSet.getPrimaryKeyObj());
3116 }
3117
3118 for (Serializable primaryKey : uncachedPrimaryKeys) {
3119 EntityCacheUtil.putResult(DDLRecordSetModelImpl.ENTITY_CACHE_ENABLED,
3120 DDLRecordSetImpl.class, primaryKey, _nullDDLRecordSet);
3121 }
3122 }
3123 catch (Exception e) {
3124 throw processException(e);
3125 }
3126 finally {
3127 closeSession(session);
3128 }
3129
3130 return map;
3131 }
3132
3133
3138 @Override
3139 public List<DDLRecordSet> findAll() {
3140 return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
3141 }
3142
3143
3154 @Override
3155 public List<DDLRecordSet> findAll(int start, int end) {
3156 return findAll(start, end, null);
3157 }
3158
3159
3171 @Override
3172 public List<DDLRecordSet> findAll(int start, int end,
3173 OrderByComparator<DDLRecordSet> orderByComparator) {
3174 boolean pagination = true;
3175 FinderPath finderPath = null;
3176 Object[] finderArgs = null;
3177
3178 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
3179 (orderByComparator == null)) {
3180 pagination = false;
3181 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL;
3182 finderArgs = FINDER_ARGS_EMPTY;
3183 }
3184 else {
3185 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_ALL;
3186 finderArgs = new Object[] { start, end, orderByComparator };
3187 }
3188
3189 List<DDLRecordSet> list = (List<DDLRecordSet>)FinderCacheUtil.getResult(finderPath,
3190 finderArgs, this);
3191
3192 if (list == null) {
3193 StringBundler query = null;
3194 String sql = null;
3195
3196 if (orderByComparator != null) {
3197 query = new StringBundler(2 +
3198 (orderByComparator.getOrderByFields().length * 3));
3199
3200 query.append(_SQL_SELECT_DDLRECORDSET);
3201
3202 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
3203 orderByComparator);
3204
3205 sql = query.toString();
3206 }
3207 else {
3208 sql = _SQL_SELECT_DDLRECORDSET;
3209
3210 if (pagination) {
3211 sql = sql.concat(DDLRecordSetModelImpl.ORDER_BY_JPQL);
3212 }
3213 }
3214
3215 Session session = null;
3216
3217 try {
3218 session = openSession();
3219
3220 Query q = session.createQuery(sql);
3221
3222 if (!pagination) {
3223 list = (List<DDLRecordSet>)QueryUtil.list(q, getDialect(),
3224 start, end, false);
3225
3226 Collections.sort(list);
3227
3228 list = Collections.unmodifiableList(list);
3229 }
3230 else {
3231 list = (List<DDLRecordSet>)QueryUtil.list(q, getDialect(),
3232 start, end);
3233 }
3234
3235 cacheResult(list);
3236
3237 FinderCacheUtil.putResult(finderPath, finderArgs, list);
3238 }
3239 catch (Exception e) {
3240 FinderCacheUtil.removeResult(finderPath, finderArgs);
3241
3242 throw processException(e);
3243 }
3244 finally {
3245 closeSession(session);
3246 }
3247 }
3248
3249 return list;
3250 }
3251
3252
3256 @Override
3257 public void removeAll() {
3258 for (DDLRecordSet ddlRecordSet : findAll()) {
3259 remove(ddlRecordSet);
3260 }
3261 }
3262
3263
3268 @Override
3269 public int countAll() {
3270 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
3271 FINDER_ARGS_EMPTY, this);
3272
3273 if (count == null) {
3274 Session session = null;
3275
3276 try {
3277 session = openSession();
3278
3279 Query q = session.createQuery(_SQL_COUNT_DDLRECORDSET);
3280
3281 count = (Long)q.uniqueResult();
3282
3283 FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL,
3284 FINDER_ARGS_EMPTY, count);
3285 }
3286 catch (Exception e) {
3287 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_ALL,
3288 FINDER_ARGS_EMPTY);
3289
3290 throw processException(e);
3291 }
3292 finally {
3293 closeSession(session);
3294 }
3295 }
3296
3297 return count.intValue();
3298 }
3299
3300 @Override
3301 protected Set<String> getBadColumnNames() {
3302 return _badColumnNames;
3303 }
3304
3305
3308 public void afterPropertiesSet() {
3309 }
3310
3311 public void destroy() {
3312 EntityCacheUtil.removeCache(DDLRecordSetImpl.class.getName());
3313 FinderCacheUtil.removeCache(FINDER_CLASS_NAME_ENTITY);
3314 FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
3315 FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
3316 }
3317
3318 private static final String _SQL_SELECT_DDLRECORDSET = "SELECT ddlRecordSet FROM DDLRecordSet ddlRecordSet";
3319 private static final String _SQL_SELECT_DDLRECORDSET_WHERE_PKS_IN = "SELECT ddlRecordSet FROM DDLRecordSet ddlRecordSet WHERE recordSetId IN (";
3320 private static final String _SQL_SELECT_DDLRECORDSET_WHERE = "SELECT ddlRecordSet FROM DDLRecordSet ddlRecordSet WHERE ";
3321 private static final String _SQL_COUNT_DDLRECORDSET = "SELECT COUNT(ddlRecordSet) FROM DDLRecordSet ddlRecordSet";
3322 private static final String _SQL_COUNT_DDLRECORDSET_WHERE = "SELECT COUNT(ddlRecordSet) FROM DDLRecordSet ddlRecordSet WHERE ";
3323 private static final String _FILTER_ENTITY_TABLE_FILTER_PK_COLUMN = "ddlRecordSet.recordSetId";
3324 private static final String _FILTER_SQL_SELECT_DDLRECORDSET_WHERE = "SELECT DISTINCT {ddlRecordSet.*} FROM DDLRecordSet ddlRecordSet WHERE ";
3325 private static final String _FILTER_SQL_SELECT_DDLRECORDSET_NO_INLINE_DISTINCT_WHERE_1 =
3326 "SELECT {DDLRecordSet.*} FROM (SELECT DISTINCT ddlRecordSet.recordSetId FROM DDLRecordSet ddlRecordSet WHERE ";
3327 private static final String _FILTER_SQL_SELECT_DDLRECORDSET_NO_INLINE_DISTINCT_WHERE_2 =
3328 ") TEMP_TABLE INNER JOIN DDLRecordSet ON TEMP_TABLE.recordSetId = DDLRecordSet.recordSetId";
3329 private static final String _FILTER_SQL_COUNT_DDLRECORDSET_WHERE = "SELECT COUNT(DISTINCT ddlRecordSet.recordSetId) AS COUNT_VALUE FROM DDLRecordSet ddlRecordSet WHERE ";
3330 private static final String _FILTER_ENTITY_ALIAS = "ddlRecordSet";
3331 private static final String _FILTER_ENTITY_TABLE = "DDLRecordSet";
3332 private static final String _ORDER_BY_ENTITY_ALIAS = "ddlRecordSet.";
3333 private static final String _ORDER_BY_ENTITY_TABLE = "DDLRecordSet.";
3334 private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No DDLRecordSet exists with the primary key ";
3335 private static final String _NO_SUCH_ENTITY_WITH_KEY = "No DDLRecordSet exists with the key {";
3336 private static final boolean _HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE = com.liferay.portal.util.PropsValues.HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE;
3337 private static final Log _log = LogFactoryUtil.getLog(DDLRecordSetPersistenceImpl.class);
3338 private static final Set<String> _badColumnNames = SetUtil.fromArray(new String[] {
3339 "uuid"
3340 });
3341 private static final DDLRecordSet _nullDDLRecordSet = new DDLRecordSetImpl() {
3342 @Override
3343 public Object clone() {
3344 return this;
3345 }
3346
3347 @Override
3348 public CacheModel<DDLRecordSet> toCacheModel() {
3349 return _nullDDLRecordSetCacheModel;
3350 }
3351 };
3352
3353 private static final CacheModel<DDLRecordSet> _nullDDLRecordSetCacheModel = new CacheModel<DDLRecordSet>() {
3354 @Override
3355 public DDLRecordSet toEntityModel() {
3356 return _nullDDLRecordSet;
3357 }
3358 };
3359 }