001
014
015 package com.liferay.portlet.documentlibrary.service.persistence;
016
017 import com.liferay.portal.kernel.cache.CacheRegistryUtil;
018 import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
019 import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
020 import com.liferay.portal.kernel.dao.orm.FinderPath;
021 import com.liferay.portal.kernel.dao.orm.Query;
022 import com.liferay.portal.kernel.dao.orm.QueryPos;
023 import com.liferay.portal.kernel.dao.orm.QueryUtil;
024 import com.liferay.portal.kernel.dao.orm.Session;
025 import com.liferay.portal.kernel.exception.SystemException;
026 import com.liferay.portal.kernel.log.Log;
027 import com.liferay.portal.kernel.log.LogFactoryUtil;
028 import com.liferay.portal.kernel.util.GetterUtil;
029 import com.liferay.portal.kernel.util.InstanceFactory;
030 import com.liferay.portal.kernel.util.OrderByComparator;
031 import com.liferay.portal.kernel.util.SetUtil;
032 import com.liferay.portal.kernel.util.StringBundler;
033 import com.liferay.portal.kernel.util.StringPool;
034 import com.liferay.portal.kernel.util.StringUtil;
035 import com.liferay.portal.kernel.util.UnmodifiableList;
036 import com.liferay.portal.kernel.util.Validator;
037 import com.liferay.portal.kernel.uuid.PortalUUIDUtil;
038 import com.liferay.portal.model.CacheModel;
039 import com.liferay.portal.model.ModelListener;
040 import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
041
042 import com.liferay.portlet.documentlibrary.NoSuchFileVersionException;
043 import com.liferay.portlet.documentlibrary.model.DLFileVersion;
044 import com.liferay.portlet.documentlibrary.model.impl.DLFileVersionImpl;
045 import com.liferay.portlet.documentlibrary.model.impl.DLFileVersionModelImpl;
046
047 import java.io.Serializable;
048
049 import java.util.ArrayList;
050 import java.util.Collections;
051 import java.util.List;
052 import java.util.Set;
053
054
066 public class DLFileVersionPersistenceImpl extends BasePersistenceImpl<DLFileVersion>
067 implements DLFileVersionPersistence {
068
073 public static final String FINDER_CLASS_NAME_ENTITY = DLFileVersionImpl.class.getName();
074 public static final String FINDER_CLASS_NAME_LIST_WITH_PAGINATION = FINDER_CLASS_NAME_ENTITY +
075 ".List1";
076 public static final String FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION = FINDER_CLASS_NAME_ENTITY +
077 ".List2";
078 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_ALL = new FinderPath(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
079 DLFileVersionModelImpl.FINDER_CACHE_ENABLED,
080 DLFileVersionImpl.class, FINDER_CLASS_NAME_LIST_WITH_PAGINATION,
081 "findAll", new String[0]);
082 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL = new FinderPath(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
083 DLFileVersionModelImpl.FINDER_CACHE_ENABLED,
084 DLFileVersionImpl.class, FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION,
085 "findAll", new String[0]);
086 public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
087 DLFileVersionModelImpl.FINDER_CACHE_ENABLED, Long.class,
088 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countAll", new String[0]);
089 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_UUID = new FinderPath(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
090 DLFileVersionModelImpl.FINDER_CACHE_ENABLED,
091 DLFileVersionImpl.class, FINDER_CLASS_NAME_LIST_WITH_PAGINATION,
092 "findByUuid",
093 new String[] {
094 String.class.getName(),
095
096 Integer.class.getName(), Integer.class.getName(),
097 OrderByComparator.class.getName()
098 });
099 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID = new FinderPath(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
100 DLFileVersionModelImpl.FINDER_CACHE_ENABLED,
101 DLFileVersionImpl.class, FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION,
102 "findByUuid", new String[] { String.class.getName() },
103 DLFileVersionModelImpl.UUID_COLUMN_BITMASK |
104 DLFileVersionModelImpl.FILEENTRYID_COLUMN_BITMASK |
105 DLFileVersionModelImpl.CREATEDATE_COLUMN_BITMASK);
106 public static final FinderPath FINDER_PATH_COUNT_BY_UUID = new FinderPath(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
107 DLFileVersionModelImpl.FINDER_CACHE_ENABLED, Long.class,
108 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByUuid",
109 new String[] { String.class.getName() });
110
111
118 @Override
119 public List<DLFileVersion> findByUuid(String uuid)
120 throws SystemException {
121 return findByUuid(uuid, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
122 }
123
124
137 @Override
138 public List<DLFileVersion> findByUuid(String uuid, int start, int end)
139 throws SystemException {
140 return findByUuid(uuid, start, end, null);
141 }
142
143
157 @Override
158 public List<DLFileVersion> findByUuid(String uuid, int start, int end,
159 OrderByComparator orderByComparator) throws SystemException {
160 boolean pagination = true;
161 FinderPath finderPath = null;
162 Object[] finderArgs = null;
163
164 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
165 (orderByComparator == null)) {
166 pagination = false;
167 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID;
168 finderArgs = new Object[] { uuid };
169 }
170 else {
171 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_UUID;
172 finderArgs = new Object[] { uuid, start, end, orderByComparator };
173 }
174
175 List<DLFileVersion> list = (List<DLFileVersion>)FinderCacheUtil.getResult(finderPath,
176 finderArgs, this);
177
178 if ((list != null) && !list.isEmpty()) {
179 for (DLFileVersion dlFileVersion : list) {
180 if (!Validator.equals(uuid, dlFileVersion.getUuid())) {
181 list = null;
182
183 break;
184 }
185 }
186 }
187
188 if (list == null) {
189 StringBundler query = null;
190
191 if (orderByComparator != null) {
192 query = new StringBundler(3 +
193 (orderByComparator.getOrderByFields().length * 3));
194 }
195 else {
196 query = new StringBundler(3);
197 }
198
199 query.append(_SQL_SELECT_DLFILEVERSION_WHERE);
200
201 boolean bindUuid = false;
202
203 if (uuid == null) {
204 query.append(_FINDER_COLUMN_UUID_UUID_1);
205 }
206 else if (uuid.equals(StringPool.BLANK)) {
207 query.append(_FINDER_COLUMN_UUID_UUID_3);
208 }
209 else {
210 bindUuid = true;
211
212 query.append(_FINDER_COLUMN_UUID_UUID_2);
213 }
214
215 if (orderByComparator != null) {
216 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
217 orderByComparator);
218 }
219 else
220 if (pagination) {
221 query.append(DLFileVersionModelImpl.ORDER_BY_JPQL);
222 }
223
224 String sql = query.toString();
225
226 Session session = null;
227
228 try {
229 session = openSession();
230
231 Query q = session.createQuery(sql);
232
233 QueryPos qPos = QueryPos.getInstance(q);
234
235 if (bindUuid) {
236 qPos.add(uuid);
237 }
238
239 if (!pagination) {
240 list = (List<DLFileVersion>)QueryUtil.list(q, getDialect(),
241 start, end, false);
242
243 Collections.sort(list);
244
245 list = new UnmodifiableList<DLFileVersion>(list);
246 }
247 else {
248 list = (List<DLFileVersion>)QueryUtil.list(q, getDialect(),
249 start, end);
250 }
251
252 cacheResult(list);
253
254 FinderCacheUtil.putResult(finderPath, finderArgs, list);
255 }
256 catch (Exception e) {
257 FinderCacheUtil.removeResult(finderPath, finderArgs);
258
259 throw processException(e);
260 }
261 finally {
262 closeSession(session);
263 }
264 }
265
266 return list;
267 }
268
269
278 @Override
279 public DLFileVersion findByUuid_First(String uuid,
280 OrderByComparator orderByComparator)
281 throws NoSuchFileVersionException, SystemException {
282 DLFileVersion dlFileVersion = fetchByUuid_First(uuid, orderByComparator);
283
284 if (dlFileVersion != null) {
285 return dlFileVersion;
286 }
287
288 StringBundler msg = new StringBundler(4);
289
290 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
291
292 msg.append("uuid=");
293 msg.append(uuid);
294
295 msg.append(StringPool.CLOSE_CURLY_BRACE);
296
297 throw new NoSuchFileVersionException(msg.toString());
298 }
299
300
308 @Override
309 public DLFileVersion fetchByUuid_First(String uuid,
310 OrderByComparator orderByComparator) throws SystemException {
311 List<DLFileVersion> list = findByUuid(uuid, 0, 1, orderByComparator);
312
313 if (!list.isEmpty()) {
314 return list.get(0);
315 }
316
317 return null;
318 }
319
320
329 @Override
330 public DLFileVersion findByUuid_Last(String uuid,
331 OrderByComparator orderByComparator)
332 throws NoSuchFileVersionException, SystemException {
333 DLFileVersion dlFileVersion = fetchByUuid_Last(uuid, orderByComparator);
334
335 if (dlFileVersion != null) {
336 return dlFileVersion;
337 }
338
339 StringBundler msg = new StringBundler(4);
340
341 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
342
343 msg.append("uuid=");
344 msg.append(uuid);
345
346 msg.append(StringPool.CLOSE_CURLY_BRACE);
347
348 throw new NoSuchFileVersionException(msg.toString());
349 }
350
351
359 @Override
360 public DLFileVersion fetchByUuid_Last(String uuid,
361 OrderByComparator orderByComparator) throws SystemException {
362 int count = countByUuid(uuid);
363
364 if (count == 0) {
365 return null;
366 }
367
368 List<DLFileVersion> list = findByUuid(uuid, count - 1, count,
369 orderByComparator);
370
371 if (!list.isEmpty()) {
372 return list.get(0);
373 }
374
375 return null;
376 }
377
378
388 @Override
389 public DLFileVersion[] findByUuid_PrevAndNext(long fileVersionId,
390 String uuid, OrderByComparator orderByComparator)
391 throws NoSuchFileVersionException, SystemException {
392 DLFileVersion dlFileVersion = findByPrimaryKey(fileVersionId);
393
394 Session session = null;
395
396 try {
397 session = openSession();
398
399 DLFileVersion[] array = new DLFileVersionImpl[3];
400
401 array[0] = getByUuid_PrevAndNext(session, dlFileVersion, uuid,
402 orderByComparator, true);
403
404 array[1] = dlFileVersion;
405
406 array[2] = getByUuid_PrevAndNext(session, dlFileVersion, uuid,
407 orderByComparator, false);
408
409 return array;
410 }
411 catch (Exception e) {
412 throw processException(e);
413 }
414 finally {
415 closeSession(session);
416 }
417 }
418
419 protected DLFileVersion getByUuid_PrevAndNext(Session session,
420 DLFileVersion dlFileVersion, String uuid,
421 OrderByComparator orderByComparator, boolean previous) {
422 StringBundler query = null;
423
424 if (orderByComparator != null) {
425 query = new StringBundler(6 +
426 (orderByComparator.getOrderByFields().length * 6));
427 }
428 else {
429 query = new StringBundler(3);
430 }
431
432 query.append(_SQL_SELECT_DLFILEVERSION_WHERE);
433
434 boolean bindUuid = false;
435
436 if (uuid == null) {
437 query.append(_FINDER_COLUMN_UUID_UUID_1);
438 }
439 else if (uuid.equals(StringPool.BLANK)) {
440 query.append(_FINDER_COLUMN_UUID_UUID_3);
441 }
442 else {
443 bindUuid = true;
444
445 query.append(_FINDER_COLUMN_UUID_UUID_2);
446 }
447
448 if (orderByComparator != null) {
449 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
450
451 if (orderByConditionFields.length > 0) {
452 query.append(WHERE_AND);
453 }
454
455 for (int i = 0; i < orderByConditionFields.length; i++) {
456 query.append(_ORDER_BY_ENTITY_ALIAS);
457 query.append(orderByConditionFields[i]);
458
459 if ((i + 1) < orderByConditionFields.length) {
460 if (orderByComparator.isAscending() ^ previous) {
461 query.append(WHERE_GREATER_THAN_HAS_NEXT);
462 }
463 else {
464 query.append(WHERE_LESSER_THAN_HAS_NEXT);
465 }
466 }
467 else {
468 if (orderByComparator.isAscending() ^ previous) {
469 query.append(WHERE_GREATER_THAN);
470 }
471 else {
472 query.append(WHERE_LESSER_THAN);
473 }
474 }
475 }
476
477 query.append(ORDER_BY_CLAUSE);
478
479 String[] orderByFields = orderByComparator.getOrderByFields();
480
481 for (int i = 0; i < orderByFields.length; i++) {
482 query.append(_ORDER_BY_ENTITY_ALIAS);
483 query.append(orderByFields[i]);
484
485 if ((i + 1) < orderByFields.length) {
486 if (orderByComparator.isAscending() ^ previous) {
487 query.append(ORDER_BY_ASC_HAS_NEXT);
488 }
489 else {
490 query.append(ORDER_BY_DESC_HAS_NEXT);
491 }
492 }
493 else {
494 if (orderByComparator.isAscending() ^ previous) {
495 query.append(ORDER_BY_ASC);
496 }
497 else {
498 query.append(ORDER_BY_DESC);
499 }
500 }
501 }
502 }
503 else {
504 query.append(DLFileVersionModelImpl.ORDER_BY_JPQL);
505 }
506
507 String sql = query.toString();
508
509 Query q = session.createQuery(sql);
510
511 q.setFirstResult(0);
512 q.setMaxResults(2);
513
514 QueryPos qPos = QueryPos.getInstance(q);
515
516 if (bindUuid) {
517 qPos.add(uuid);
518 }
519
520 if (orderByComparator != null) {
521 Object[] values = orderByComparator.getOrderByConditionValues(dlFileVersion);
522
523 for (Object value : values) {
524 qPos.add(value);
525 }
526 }
527
528 List<DLFileVersion> list = q.list();
529
530 if (list.size() == 2) {
531 return list.get(1);
532 }
533 else {
534 return null;
535 }
536 }
537
538
544 @Override
545 public void removeByUuid(String uuid) throws SystemException {
546 for (DLFileVersion dlFileVersion : findByUuid(uuid, QueryUtil.ALL_POS,
547 QueryUtil.ALL_POS, null)) {
548 remove(dlFileVersion);
549 }
550 }
551
552
559 @Override
560 public int countByUuid(String uuid) throws SystemException {
561 FinderPath finderPath = FINDER_PATH_COUNT_BY_UUID;
562
563 Object[] finderArgs = new Object[] { uuid };
564
565 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
566 this);
567
568 if (count == null) {
569 StringBundler query = new StringBundler(2);
570
571 query.append(_SQL_COUNT_DLFILEVERSION_WHERE);
572
573 boolean bindUuid = false;
574
575 if (uuid == null) {
576 query.append(_FINDER_COLUMN_UUID_UUID_1);
577 }
578 else if (uuid.equals(StringPool.BLANK)) {
579 query.append(_FINDER_COLUMN_UUID_UUID_3);
580 }
581 else {
582 bindUuid = true;
583
584 query.append(_FINDER_COLUMN_UUID_UUID_2);
585 }
586
587 String sql = query.toString();
588
589 Session session = null;
590
591 try {
592 session = openSession();
593
594 Query q = session.createQuery(sql);
595
596 QueryPos qPos = QueryPos.getInstance(q);
597
598 if (bindUuid) {
599 qPos.add(uuid);
600 }
601
602 count = (Long)q.uniqueResult();
603
604 FinderCacheUtil.putResult(finderPath, finderArgs, count);
605 }
606 catch (Exception e) {
607 FinderCacheUtil.removeResult(finderPath, finderArgs);
608
609 throw processException(e);
610 }
611 finally {
612 closeSession(session);
613 }
614 }
615
616 return count.intValue();
617 }
618
619 private static final String _FINDER_COLUMN_UUID_UUID_1 = "dlFileVersion.uuid IS NULL";
620 private static final String _FINDER_COLUMN_UUID_UUID_2 = "dlFileVersion.uuid = ?";
621 private static final String _FINDER_COLUMN_UUID_UUID_3 = "(dlFileVersion.uuid IS NULL OR dlFileVersion.uuid = '')";
622 public static final FinderPath FINDER_PATH_FETCH_BY_UUID_G = new FinderPath(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
623 DLFileVersionModelImpl.FINDER_CACHE_ENABLED,
624 DLFileVersionImpl.class, FINDER_CLASS_NAME_ENTITY, "fetchByUUID_G",
625 new String[] { String.class.getName(), Long.class.getName() },
626 DLFileVersionModelImpl.UUID_COLUMN_BITMASK |
627 DLFileVersionModelImpl.GROUPID_COLUMN_BITMASK);
628 public static final FinderPath FINDER_PATH_COUNT_BY_UUID_G = new FinderPath(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
629 DLFileVersionModelImpl.FINDER_CACHE_ENABLED, Long.class,
630 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByUUID_G",
631 new String[] { String.class.getName(), Long.class.getName() });
632
633
642 @Override
643 public DLFileVersion findByUUID_G(String uuid, long groupId)
644 throws NoSuchFileVersionException, SystemException {
645 DLFileVersion dlFileVersion = fetchByUUID_G(uuid, groupId);
646
647 if (dlFileVersion == null) {
648 StringBundler msg = new StringBundler(6);
649
650 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
651
652 msg.append("uuid=");
653 msg.append(uuid);
654
655 msg.append(", groupId=");
656 msg.append(groupId);
657
658 msg.append(StringPool.CLOSE_CURLY_BRACE);
659
660 if (_log.isWarnEnabled()) {
661 _log.warn(msg.toString());
662 }
663
664 throw new NoSuchFileVersionException(msg.toString());
665 }
666
667 return dlFileVersion;
668 }
669
670
678 @Override
679 public DLFileVersion fetchByUUID_G(String uuid, long groupId)
680 throws SystemException {
681 return fetchByUUID_G(uuid, groupId, true);
682 }
683
684
693 @Override
694 public DLFileVersion fetchByUUID_G(String uuid, long groupId,
695 boolean retrieveFromCache) throws SystemException {
696 Object[] finderArgs = new Object[] { uuid, groupId };
697
698 Object result = null;
699
700 if (retrieveFromCache) {
701 result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_UUID_G,
702 finderArgs, this);
703 }
704
705 if (result instanceof DLFileVersion) {
706 DLFileVersion dlFileVersion = (DLFileVersion)result;
707
708 if (!Validator.equals(uuid, dlFileVersion.getUuid()) ||
709 (groupId != dlFileVersion.getGroupId())) {
710 result = null;
711 }
712 }
713
714 if (result == null) {
715 StringBundler query = new StringBundler(4);
716
717 query.append(_SQL_SELECT_DLFILEVERSION_WHERE);
718
719 boolean bindUuid = false;
720
721 if (uuid == null) {
722 query.append(_FINDER_COLUMN_UUID_G_UUID_1);
723 }
724 else if (uuid.equals(StringPool.BLANK)) {
725 query.append(_FINDER_COLUMN_UUID_G_UUID_3);
726 }
727 else {
728 bindUuid = true;
729
730 query.append(_FINDER_COLUMN_UUID_G_UUID_2);
731 }
732
733 query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
734
735 String sql = query.toString();
736
737 Session session = null;
738
739 try {
740 session = openSession();
741
742 Query q = session.createQuery(sql);
743
744 QueryPos qPos = QueryPos.getInstance(q);
745
746 if (bindUuid) {
747 qPos.add(uuid);
748 }
749
750 qPos.add(groupId);
751
752 List<DLFileVersion> list = q.list();
753
754 if (list.isEmpty()) {
755 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
756 finderArgs, list);
757 }
758 else {
759 DLFileVersion dlFileVersion = list.get(0);
760
761 result = dlFileVersion;
762
763 cacheResult(dlFileVersion);
764
765 if ((dlFileVersion.getUuid() == null) ||
766 !dlFileVersion.getUuid().equals(uuid) ||
767 (dlFileVersion.getGroupId() != groupId)) {
768 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
769 finderArgs, dlFileVersion);
770 }
771 }
772 }
773 catch (Exception e) {
774 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
775 finderArgs);
776
777 throw processException(e);
778 }
779 finally {
780 closeSession(session);
781 }
782 }
783
784 if (result instanceof List<?>) {
785 return null;
786 }
787 else {
788 return (DLFileVersion)result;
789 }
790 }
791
792
800 @Override
801 public DLFileVersion removeByUUID_G(String uuid, long groupId)
802 throws NoSuchFileVersionException, SystemException {
803 DLFileVersion dlFileVersion = findByUUID_G(uuid, groupId);
804
805 return remove(dlFileVersion);
806 }
807
808
816 @Override
817 public int countByUUID_G(String uuid, long groupId)
818 throws SystemException {
819 FinderPath finderPath = FINDER_PATH_COUNT_BY_UUID_G;
820
821 Object[] finderArgs = new Object[] { uuid, groupId };
822
823 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
824 this);
825
826 if (count == null) {
827 StringBundler query = new StringBundler(3);
828
829 query.append(_SQL_COUNT_DLFILEVERSION_WHERE);
830
831 boolean bindUuid = false;
832
833 if (uuid == null) {
834 query.append(_FINDER_COLUMN_UUID_G_UUID_1);
835 }
836 else if (uuid.equals(StringPool.BLANK)) {
837 query.append(_FINDER_COLUMN_UUID_G_UUID_3);
838 }
839 else {
840 bindUuid = true;
841
842 query.append(_FINDER_COLUMN_UUID_G_UUID_2);
843 }
844
845 query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
846
847 String sql = query.toString();
848
849 Session session = null;
850
851 try {
852 session = openSession();
853
854 Query q = session.createQuery(sql);
855
856 QueryPos qPos = QueryPos.getInstance(q);
857
858 if (bindUuid) {
859 qPos.add(uuid);
860 }
861
862 qPos.add(groupId);
863
864 count = (Long)q.uniqueResult();
865
866 FinderCacheUtil.putResult(finderPath, finderArgs, count);
867 }
868 catch (Exception e) {
869 FinderCacheUtil.removeResult(finderPath, finderArgs);
870
871 throw processException(e);
872 }
873 finally {
874 closeSession(session);
875 }
876 }
877
878 return count.intValue();
879 }
880
881 private static final String _FINDER_COLUMN_UUID_G_UUID_1 = "dlFileVersion.uuid IS NULL AND ";
882 private static final String _FINDER_COLUMN_UUID_G_UUID_2 = "dlFileVersion.uuid = ? AND ";
883 private static final String _FINDER_COLUMN_UUID_G_UUID_3 = "(dlFileVersion.uuid IS NULL OR dlFileVersion.uuid = '') AND ";
884 private static final String _FINDER_COLUMN_UUID_G_GROUPID_2 = "dlFileVersion.groupId = ?";
885 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_UUID_C = new FinderPath(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
886 DLFileVersionModelImpl.FINDER_CACHE_ENABLED,
887 DLFileVersionImpl.class, FINDER_CLASS_NAME_LIST_WITH_PAGINATION,
888 "findByUuid_C",
889 new String[] {
890 String.class.getName(), Long.class.getName(),
891
892 Integer.class.getName(), Integer.class.getName(),
893 OrderByComparator.class.getName()
894 });
895 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C =
896 new FinderPath(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
897 DLFileVersionModelImpl.FINDER_CACHE_ENABLED,
898 DLFileVersionImpl.class, FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION,
899 "findByUuid_C",
900 new String[] { String.class.getName(), Long.class.getName() },
901 DLFileVersionModelImpl.UUID_COLUMN_BITMASK |
902 DLFileVersionModelImpl.COMPANYID_COLUMN_BITMASK |
903 DLFileVersionModelImpl.FILEENTRYID_COLUMN_BITMASK |
904 DLFileVersionModelImpl.CREATEDATE_COLUMN_BITMASK);
905 public static final FinderPath FINDER_PATH_COUNT_BY_UUID_C = new FinderPath(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
906 DLFileVersionModelImpl.FINDER_CACHE_ENABLED, Long.class,
907 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByUuid_C",
908 new String[] { String.class.getName(), Long.class.getName() });
909
910
918 @Override
919 public List<DLFileVersion> findByUuid_C(String uuid, long companyId)
920 throws SystemException {
921 return findByUuid_C(uuid, companyId, QueryUtil.ALL_POS,
922 QueryUtil.ALL_POS, null);
923 }
924
925
939 @Override
940 public List<DLFileVersion> findByUuid_C(String uuid, long companyId,
941 int start, int end) throws SystemException {
942 return findByUuid_C(uuid, companyId, start, end, null);
943 }
944
945
960 @Override
961 public List<DLFileVersion> findByUuid_C(String uuid, long companyId,
962 int start, int end, OrderByComparator orderByComparator)
963 throws SystemException {
964 boolean pagination = true;
965 FinderPath finderPath = null;
966 Object[] finderArgs = null;
967
968 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
969 (orderByComparator == null)) {
970 pagination = false;
971 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C;
972 finderArgs = new Object[] { uuid, companyId };
973 }
974 else {
975 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_UUID_C;
976 finderArgs = new Object[] {
977 uuid, companyId,
978
979 start, end, orderByComparator
980 };
981 }
982
983 List<DLFileVersion> list = (List<DLFileVersion>)FinderCacheUtil.getResult(finderPath,
984 finderArgs, this);
985
986 if ((list != null) && !list.isEmpty()) {
987 for (DLFileVersion dlFileVersion : list) {
988 if (!Validator.equals(uuid, dlFileVersion.getUuid()) ||
989 (companyId != dlFileVersion.getCompanyId())) {
990 list = null;
991
992 break;
993 }
994 }
995 }
996
997 if (list == null) {
998 StringBundler query = null;
999
1000 if (orderByComparator != null) {
1001 query = new StringBundler(4 +
1002 (orderByComparator.getOrderByFields().length * 3));
1003 }
1004 else {
1005 query = new StringBundler(4);
1006 }
1007
1008 query.append(_SQL_SELECT_DLFILEVERSION_WHERE);
1009
1010 boolean bindUuid = false;
1011
1012 if (uuid == null) {
1013 query.append(_FINDER_COLUMN_UUID_C_UUID_1);
1014 }
1015 else if (uuid.equals(StringPool.BLANK)) {
1016 query.append(_FINDER_COLUMN_UUID_C_UUID_3);
1017 }
1018 else {
1019 bindUuid = true;
1020
1021 query.append(_FINDER_COLUMN_UUID_C_UUID_2);
1022 }
1023
1024 query.append(_FINDER_COLUMN_UUID_C_COMPANYID_2);
1025
1026 if (orderByComparator != null) {
1027 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1028 orderByComparator);
1029 }
1030 else
1031 if (pagination) {
1032 query.append(DLFileVersionModelImpl.ORDER_BY_JPQL);
1033 }
1034
1035 String sql = query.toString();
1036
1037 Session session = null;
1038
1039 try {
1040 session = openSession();
1041
1042 Query q = session.createQuery(sql);
1043
1044 QueryPos qPos = QueryPos.getInstance(q);
1045
1046 if (bindUuid) {
1047 qPos.add(uuid);
1048 }
1049
1050 qPos.add(companyId);
1051
1052 if (!pagination) {
1053 list = (List<DLFileVersion>)QueryUtil.list(q, getDialect(),
1054 start, end, false);
1055
1056 Collections.sort(list);
1057
1058 list = new UnmodifiableList<DLFileVersion>(list);
1059 }
1060 else {
1061 list = (List<DLFileVersion>)QueryUtil.list(q, getDialect(),
1062 start, end);
1063 }
1064
1065 cacheResult(list);
1066
1067 FinderCacheUtil.putResult(finderPath, finderArgs, list);
1068 }
1069 catch (Exception e) {
1070 FinderCacheUtil.removeResult(finderPath, finderArgs);
1071
1072 throw processException(e);
1073 }
1074 finally {
1075 closeSession(session);
1076 }
1077 }
1078
1079 return list;
1080 }
1081
1082
1092 @Override
1093 public DLFileVersion findByUuid_C_First(String uuid, long companyId,
1094 OrderByComparator orderByComparator)
1095 throws NoSuchFileVersionException, SystemException {
1096 DLFileVersion dlFileVersion = fetchByUuid_C_First(uuid, companyId,
1097 orderByComparator);
1098
1099 if (dlFileVersion != null) {
1100 return dlFileVersion;
1101 }
1102
1103 StringBundler msg = new StringBundler(6);
1104
1105 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1106
1107 msg.append("uuid=");
1108 msg.append(uuid);
1109
1110 msg.append(", companyId=");
1111 msg.append(companyId);
1112
1113 msg.append(StringPool.CLOSE_CURLY_BRACE);
1114
1115 throw new NoSuchFileVersionException(msg.toString());
1116 }
1117
1118
1127 @Override
1128 public DLFileVersion fetchByUuid_C_First(String uuid, long companyId,
1129 OrderByComparator orderByComparator) throws SystemException {
1130 List<DLFileVersion> list = findByUuid_C(uuid, companyId, 0, 1,
1131 orderByComparator);
1132
1133 if (!list.isEmpty()) {
1134 return list.get(0);
1135 }
1136
1137 return null;
1138 }
1139
1140
1150 @Override
1151 public DLFileVersion findByUuid_C_Last(String uuid, long companyId,
1152 OrderByComparator orderByComparator)
1153 throws NoSuchFileVersionException, SystemException {
1154 DLFileVersion dlFileVersion = fetchByUuid_C_Last(uuid, companyId,
1155 orderByComparator);
1156
1157 if (dlFileVersion != null) {
1158 return dlFileVersion;
1159 }
1160
1161 StringBundler msg = new StringBundler(6);
1162
1163 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1164
1165 msg.append("uuid=");
1166 msg.append(uuid);
1167
1168 msg.append(", companyId=");
1169 msg.append(companyId);
1170
1171 msg.append(StringPool.CLOSE_CURLY_BRACE);
1172
1173 throw new NoSuchFileVersionException(msg.toString());
1174 }
1175
1176
1185 @Override
1186 public DLFileVersion fetchByUuid_C_Last(String uuid, long companyId,
1187 OrderByComparator orderByComparator) throws SystemException {
1188 int count = countByUuid_C(uuid, companyId);
1189
1190 if (count == 0) {
1191 return null;
1192 }
1193
1194 List<DLFileVersion> list = findByUuid_C(uuid, companyId, count - 1,
1195 count, orderByComparator);
1196
1197 if (!list.isEmpty()) {
1198 return list.get(0);
1199 }
1200
1201 return null;
1202 }
1203
1204
1215 @Override
1216 public DLFileVersion[] findByUuid_C_PrevAndNext(long fileVersionId,
1217 String uuid, long companyId, OrderByComparator orderByComparator)
1218 throws NoSuchFileVersionException, SystemException {
1219 DLFileVersion dlFileVersion = findByPrimaryKey(fileVersionId);
1220
1221 Session session = null;
1222
1223 try {
1224 session = openSession();
1225
1226 DLFileVersion[] array = new DLFileVersionImpl[3];
1227
1228 array[0] = getByUuid_C_PrevAndNext(session, dlFileVersion, uuid,
1229 companyId, orderByComparator, true);
1230
1231 array[1] = dlFileVersion;
1232
1233 array[2] = getByUuid_C_PrevAndNext(session, dlFileVersion, uuid,
1234 companyId, orderByComparator, false);
1235
1236 return array;
1237 }
1238 catch (Exception e) {
1239 throw processException(e);
1240 }
1241 finally {
1242 closeSession(session);
1243 }
1244 }
1245
1246 protected DLFileVersion getByUuid_C_PrevAndNext(Session session,
1247 DLFileVersion dlFileVersion, String uuid, long companyId,
1248 OrderByComparator orderByComparator, boolean previous) {
1249 StringBundler query = null;
1250
1251 if (orderByComparator != null) {
1252 query = new StringBundler(6 +
1253 (orderByComparator.getOrderByFields().length * 6));
1254 }
1255 else {
1256 query = new StringBundler(3);
1257 }
1258
1259 query.append(_SQL_SELECT_DLFILEVERSION_WHERE);
1260
1261 boolean bindUuid = false;
1262
1263 if (uuid == null) {
1264 query.append(_FINDER_COLUMN_UUID_C_UUID_1);
1265 }
1266 else if (uuid.equals(StringPool.BLANK)) {
1267 query.append(_FINDER_COLUMN_UUID_C_UUID_3);
1268 }
1269 else {
1270 bindUuid = true;
1271
1272 query.append(_FINDER_COLUMN_UUID_C_UUID_2);
1273 }
1274
1275 query.append(_FINDER_COLUMN_UUID_C_COMPANYID_2);
1276
1277 if (orderByComparator != null) {
1278 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
1279
1280 if (orderByConditionFields.length > 0) {
1281 query.append(WHERE_AND);
1282 }
1283
1284 for (int i = 0; i < orderByConditionFields.length; i++) {
1285 query.append(_ORDER_BY_ENTITY_ALIAS);
1286 query.append(orderByConditionFields[i]);
1287
1288 if ((i + 1) < orderByConditionFields.length) {
1289 if (orderByComparator.isAscending() ^ previous) {
1290 query.append(WHERE_GREATER_THAN_HAS_NEXT);
1291 }
1292 else {
1293 query.append(WHERE_LESSER_THAN_HAS_NEXT);
1294 }
1295 }
1296 else {
1297 if (orderByComparator.isAscending() ^ previous) {
1298 query.append(WHERE_GREATER_THAN);
1299 }
1300 else {
1301 query.append(WHERE_LESSER_THAN);
1302 }
1303 }
1304 }
1305
1306 query.append(ORDER_BY_CLAUSE);
1307
1308 String[] orderByFields = orderByComparator.getOrderByFields();
1309
1310 for (int i = 0; i < orderByFields.length; i++) {
1311 query.append(_ORDER_BY_ENTITY_ALIAS);
1312 query.append(orderByFields[i]);
1313
1314 if ((i + 1) < orderByFields.length) {
1315 if (orderByComparator.isAscending() ^ previous) {
1316 query.append(ORDER_BY_ASC_HAS_NEXT);
1317 }
1318 else {
1319 query.append(ORDER_BY_DESC_HAS_NEXT);
1320 }
1321 }
1322 else {
1323 if (orderByComparator.isAscending() ^ previous) {
1324 query.append(ORDER_BY_ASC);
1325 }
1326 else {
1327 query.append(ORDER_BY_DESC);
1328 }
1329 }
1330 }
1331 }
1332 else {
1333 query.append(DLFileVersionModelImpl.ORDER_BY_JPQL);
1334 }
1335
1336 String sql = query.toString();
1337
1338 Query q = session.createQuery(sql);
1339
1340 q.setFirstResult(0);
1341 q.setMaxResults(2);
1342
1343 QueryPos qPos = QueryPos.getInstance(q);
1344
1345 if (bindUuid) {
1346 qPos.add(uuid);
1347 }
1348
1349 qPos.add(companyId);
1350
1351 if (orderByComparator != null) {
1352 Object[] values = orderByComparator.getOrderByConditionValues(dlFileVersion);
1353
1354 for (Object value : values) {
1355 qPos.add(value);
1356 }
1357 }
1358
1359 List<DLFileVersion> list = q.list();
1360
1361 if (list.size() == 2) {
1362 return list.get(1);
1363 }
1364 else {
1365 return null;
1366 }
1367 }
1368
1369
1376 @Override
1377 public void removeByUuid_C(String uuid, long companyId)
1378 throws SystemException {
1379 for (DLFileVersion dlFileVersion : findByUuid_C(uuid, companyId,
1380 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
1381 remove(dlFileVersion);
1382 }
1383 }
1384
1385
1393 @Override
1394 public int countByUuid_C(String uuid, long companyId)
1395 throws SystemException {
1396 FinderPath finderPath = FINDER_PATH_COUNT_BY_UUID_C;
1397
1398 Object[] finderArgs = new Object[] { uuid, companyId };
1399
1400 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
1401 this);
1402
1403 if (count == null) {
1404 StringBundler query = new StringBundler(3);
1405
1406 query.append(_SQL_COUNT_DLFILEVERSION_WHERE);
1407
1408 boolean bindUuid = false;
1409
1410 if (uuid == null) {
1411 query.append(_FINDER_COLUMN_UUID_C_UUID_1);
1412 }
1413 else if (uuid.equals(StringPool.BLANK)) {
1414 query.append(_FINDER_COLUMN_UUID_C_UUID_3);
1415 }
1416 else {
1417 bindUuid = true;
1418
1419 query.append(_FINDER_COLUMN_UUID_C_UUID_2);
1420 }
1421
1422 query.append(_FINDER_COLUMN_UUID_C_COMPANYID_2);
1423
1424 String sql = query.toString();
1425
1426 Session session = null;
1427
1428 try {
1429 session = openSession();
1430
1431 Query q = session.createQuery(sql);
1432
1433 QueryPos qPos = QueryPos.getInstance(q);
1434
1435 if (bindUuid) {
1436 qPos.add(uuid);
1437 }
1438
1439 qPos.add(companyId);
1440
1441 count = (Long)q.uniqueResult();
1442
1443 FinderCacheUtil.putResult(finderPath, finderArgs, count);
1444 }
1445 catch (Exception e) {
1446 FinderCacheUtil.removeResult(finderPath, finderArgs);
1447
1448 throw processException(e);
1449 }
1450 finally {
1451 closeSession(session);
1452 }
1453 }
1454
1455 return count.intValue();
1456 }
1457
1458 private static final String _FINDER_COLUMN_UUID_C_UUID_1 = "dlFileVersion.uuid IS NULL AND ";
1459 private static final String _FINDER_COLUMN_UUID_C_UUID_2 = "dlFileVersion.uuid = ? AND ";
1460 private static final String _FINDER_COLUMN_UUID_C_UUID_3 = "(dlFileVersion.uuid IS NULL OR dlFileVersion.uuid = '') AND ";
1461 private static final String _FINDER_COLUMN_UUID_C_COMPANYID_2 = "dlFileVersion.companyId = ?";
1462 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_FILEENTRYID =
1463 new FinderPath(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
1464 DLFileVersionModelImpl.FINDER_CACHE_ENABLED,
1465 DLFileVersionImpl.class, FINDER_CLASS_NAME_LIST_WITH_PAGINATION,
1466 "findByFileEntryId",
1467 new String[] {
1468 Long.class.getName(),
1469
1470 Integer.class.getName(), Integer.class.getName(),
1471 OrderByComparator.class.getName()
1472 });
1473 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_FILEENTRYID =
1474 new FinderPath(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
1475 DLFileVersionModelImpl.FINDER_CACHE_ENABLED,
1476 DLFileVersionImpl.class, FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION,
1477 "findByFileEntryId", new String[] { Long.class.getName() },
1478 DLFileVersionModelImpl.FILEENTRYID_COLUMN_BITMASK |
1479 DLFileVersionModelImpl.CREATEDATE_COLUMN_BITMASK);
1480 public static final FinderPath FINDER_PATH_COUNT_BY_FILEENTRYID = new FinderPath(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
1481 DLFileVersionModelImpl.FINDER_CACHE_ENABLED, Long.class,
1482 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByFileEntryId",
1483 new String[] { Long.class.getName() });
1484
1485
1492 @Override
1493 public List<DLFileVersion> findByFileEntryId(long fileEntryId)
1494 throws SystemException {
1495 return findByFileEntryId(fileEntryId, QueryUtil.ALL_POS,
1496 QueryUtil.ALL_POS, null);
1497 }
1498
1499
1512 @Override
1513 public List<DLFileVersion> findByFileEntryId(long fileEntryId, int start,
1514 int end) throws SystemException {
1515 return findByFileEntryId(fileEntryId, start, end, null);
1516 }
1517
1518
1532 @Override
1533 public List<DLFileVersion> findByFileEntryId(long fileEntryId, int start,
1534 int end, OrderByComparator orderByComparator) throws SystemException {
1535 boolean pagination = true;
1536 FinderPath finderPath = null;
1537 Object[] finderArgs = null;
1538
1539 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
1540 (orderByComparator == null)) {
1541 pagination = false;
1542 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_FILEENTRYID;
1543 finderArgs = new Object[] { fileEntryId };
1544 }
1545 else {
1546 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_FILEENTRYID;
1547 finderArgs = new Object[] { fileEntryId, start, end, orderByComparator };
1548 }
1549
1550 List<DLFileVersion> list = (List<DLFileVersion>)FinderCacheUtil.getResult(finderPath,
1551 finderArgs, this);
1552
1553 if ((list != null) && !list.isEmpty()) {
1554 for (DLFileVersion dlFileVersion : list) {
1555 if ((fileEntryId != dlFileVersion.getFileEntryId())) {
1556 list = null;
1557
1558 break;
1559 }
1560 }
1561 }
1562
1563 if (list == null) {
1564 StringBundler query = null;
1565
1566 if (orderByComparator != null) {
1567 query = new StringBundler(3 +
1568 (orderByComparator.getOrderByFields().length * 3));
1569 }
1570 else {
1571 query = new StringBundler(3);
1572 }
1573
1574 query.append(_SQL_SELECT_DLFILEVERSION_WHERE);
1575
1576 query.append(_FINDER_COLUMN_FILEENTRYID_FILEENTRYID_2);
1577
1578 if (orderByComparator != null) {
1579 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1580 orderByComparator);
1581 }
1582 else
1583 if (pagination) {
1584 query.append(DLFileVersionModelImpl.ORDER_BY_JPQL);
1585 }
1586
1587 String sql = query.toString();
1588
1589 Session session = null;
1590
1591 try {
1592 session = openSession();
1593
1594 Query q = session.createQuery(sql);
1595
1596 QueryPos qPos = QueryPos.getInstance(q);
1597
1598 qPos.add(fileEntryId);
1599
1600 if (!pagination) {
1601 list = (List<DLFileVersion>)QueryUtil.list(q, getDialect(),
1602 start, end, false);
1603
1604 Collections.sort(list);
1605
1606 list = new UnmodifiableList<DLFileVersion>(list);
1607 }
1608 else {
1609 list = (List<DLFileVersion>)QueryUtil.list(q, getDialect(),
1610 start, end);
1611 }
1612
1613 cacheResult(list);
1614
1615 FinderCacheUtil.putResult(finderPath, finderArgs, list);
1616 }
1617 catch (Exception e) {
1618 FinderCacheUtil.removeResult(finderPath, finderArgs);
1619
1620 throw processException(e);
1621 }
1622 finally {
1623 closeSession(session);
1624 }
1625 }
1626
1627 return list;
1628 }
1629
1630
1639 @Override
1640 public DLFileVersion findByFileEntryId_First(long fileEntryId,
1641 OrderByComparator orderByComparator)
1642 throws NoSuchFileVersionException, SystemException {
1643 DLFileVersion dlFileVersion = fetchByFileEntryId_First(fileEntryId,
1644 orderByComparator);
1645
1646 if (dlFileVersion != null) {
1647 return dlFileVersion;
1648 }
1649
1650 StringBundler msg = new StringBundler(4);
1651
1652 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1653
1654 msg.append("fileEntryId=");
1655 msg.append(fileEntryId);
1656
1657 msg.append(StringPool.CLOSE_CURLY_BRACE);
1658
1659 throw new NoSuchFileVersionException(msg.toString());
1660 }
1661
1662
1670 @Override
1671 public DLFileVersion fetchByFileEntryId_First(long fileEntryId,
1672 OrderByComparator orderByComparator) throws SystemException {
1673 List<DLFileVersion> list = findByFileEntryId(fileEntryId, 0, 1,
1674 orderByComparator);
1675
1676 if (!list.isEmpty()) {
1677 return list.get(0);
1678 }
1679
1680 return null;
1681 }
1682
1683
1692 @Override
1693 public DLFileVersion findByFileEntryId_Last(long fileEntryId,
1694 OrderByComparator orderByComparator)
1695 throws NoSuchFileVersionException, SystemException {
1696 DLFileVersion dlFileVersion = fetchByFileEntryId_Last(fileEntryId,
1697 orderByComparator);
1698
1699 if (dlFileVersion != null) {
1700 return dlFileVersion;
1701 }
1702
1703 StringBundler msg = new StringBundler(4);
1704
1705 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1706
1707 msg.append("fileEntryId=");
1708 msg.append(fileEntryId);
1709
1710 msg.append(StringPool.CLOSE_CURLY_BRACE);
1711
1712 throw new NoSuchFileVersionException(msg.toString());
1713 }
1714
1715
1723 @Override
1724 public DLFileVersion fetchByFileEntryId_Last(long fileEntryId,
1725 OrderByComparator orderByComparator) throws SystemException {
1726 int count = countByFileEntryId(fileEntryId);
1727
1728 if (count == 0) {
1729 return null;
1730 }
1731
1732 List<DLFileVersion> list = findByFileEntryId(fileEntryId, count - 1,
1733 count, orderByComparator);
1734
1735 if (!list.isEmpty()) {
1736 return list.get(0);
1737 }
1738
1739 return null;
1740 }
1741
1742
1752 @Override
1753 public DLFileVersion[] findByFileEntryId_PrevAndNext(long fileVersionId,
1754 long fileEntryId, OrderByComparator orderByComparator)
1755 throws NoSuchFileVersionException, SystemException {
1756 DLFileVersion dlFileVersion = findByPrimaryKey(fileVersionId);
1757
1758 Session session = null;
1759
1760 try {
1761 session = openSession();
1762
1763 DLFileVersion[] array = new DLFileVersionImpl[3];
1764
1765 array[0] = getByFileEntryId_PrevAndNext(session, dlFileVersion,
1766 fileEntryId, orderByComparator, true);
1767
1768 array[1] = dlFileVersion;
1769
1770 array[2] = getByFileEntryId_PrevAndNext(session, dlFileVersion,
1771 fileEntryId, orderByComparator, false);
1772
1773 return array;
1774 }
1775 catch (Exception e) {
1776 throw processException(e);
1777 }
1778 finally {
1779 closeSession(session);
1780 }
1781 }
1782
1783 protected DLFileVersion getByFileEntryId_PrevAndNext(Session session,
1784 DLFileVersion dlFileVersion, long fileEntryId,
1785 OrderByComparator orderByComparator, boolean previous) {
1786 StringBundler query = null;
1787
1788 if (orderByComparator != null) {
1789 query = new StringBundler(6 +
1790 (orderByComparator.getOrderByFields().length * 6));
1791 }
1792 else {
1793 query = new StringBundler(3);
1794 }
1795
1796 query.append(_SQL_SELECT_DLFILEVERSION_WHERE);
1797
1798 query.append(_FINDER_COLUMN_FILEENTRYID_FILEENTRYID_2);
1799
1800 if (orderByComparator != null) {
1801 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
1802
1803 if (orderByConditionFields.length > 0) {
1804 query.append(WHERE_AND);
1805 }
1806
1807 for (int i = 0; i < orderByConditionFields.length; i++) {
1808 query.append(_ORDER_BY_ENTITY_ALIAS);
1809 query.append(orderByConditionFields[i]);
1810
1811 if ((i + 1) < orderByConditionFields.length) {
1812 if (orderByComparator.isAscending() ^ previous) {
1813 query.append(WHERE_GREATER_THAN_HAS_NEXT);
1814 }
1815 else {
1816 query.append(WHERE_LESSER_THAN_HAS_NEXT);
1817 }
1818 }
1819 else {
1820 if (orderByComparator.isAscending() ^ previous) {
1821 query.append(WHERE_GREATER_THAN);
1822 }
1823 else {
1824 query.append(WHERE_LESSER_THAN);
1825 }
1826 }
1827 }
1828
1829 query.append(ORDER_BY_CLAUSE);
1830
1831 String[] orderByFields = orderByComparator.getOrderByFields();
1832
1833 for (int i = 0; i < orderByFields.length; i++) {
1834 query.append(_ORDER_BY_ENTITY_ALIAS);
1835 query.append(orderByFields[i]);
1836
1837 if ((i + 1) < orderByFields.length) {
1838 if (orderByComparator.isAscending() ^ previous) {
1839 query.append(ORDER_BY_ASC_HAS_NEXT);
1840 }
1841 else {
1842 query.append(ORDER_BY_DESC_HAS_NEXT);
1843 }
1844 }
1845 else {
1846 if (orderByComparator.isAscending() ^ previous) {
1847 query.append(ORDER_BY_ASC);
1848 }
1849 else {
1850 query.append(ORDER_BY_DESC);
1851 }
1852 }
1853 }
1854 }
1855 else {
1856 query.append(DLFileVersionModelImpl.ORDER_BY_JPQL);
1857 }
1858
1859 String sql = query.toString();
1860
1861 Query q = session.createQuery(sql);
1862
1863 q.setFirstResult(0);
1864 q.setMaxResults(2);
1865
1866 QueryPos qPos = QueryPos.getInstance(q);
1867
1868 qPos.add(fileEntryId);
1869
1870 if (orderByComparator != null) {
1871 Object[] values = orderByComparator.getOrderByConditionValues(dlFileVersion);
1872
1873 for (Object value : values) {
1874 qPos.add(value);
1875 }
1876 }
1877
1878 List<DLFileVersion> list = q.list();
1879
1880 if (list.size() == 2) {
1881 return list.get(1);
1882 }
1883 else {
1884 return null;
1885 }
1886 }
1887
1888
1894 @Override
1895 public void removeByFileEntryId(long fileEntryId) throws SystemException {
1896 for (DLFileVersion dlFileVersion : findByFileEntryId(fileEntryId,
1897 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
1898 remove(dlFileVersion);
1899 }
1900 }
1901
1902
1909 @Override
1910 public int countByFileEntryId(long fileEntryId) throws SystemException {
1911 FinderPath finderPath = FINDER_PATH_COUNT_BY_FILEENTRYID;
1912
1913 Object[] finderArgs = new Object[] { fileEntryId };
1914
1915 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
1916 this);
1917
1918 if (count == null) {
1919 StringBundler query = new StringBundler(2);
1920
1921 query.append(_SQL_COUNT_DLFILEVERSION_WHERE);
1922
1923 query.append(_FINDER_COLUMN_FILEENTRYID_FILEENTRYID_2);
1924
1925 String sql = query.toString();
1926
1927 Session session = null;
1928
1929 try {
1930 session = openSession();
1931
1932 Query q = session.createQuery(sql);
1933
1934 QueryPos qPos = QueryPos.getInstance(q);
1935
1936 qPos.add(fileEntryId);
1937
1938 count = (Long)q.uniqueResult();
1939
1940 FinderCacheUtil.putResult(finderPath, finderArgs, count);
1941 }
1942 catch (Exception e) {
1943 FinderCacheUtil.removeResult(finderPath, finderArgs);
1944
1945 throw processException(e);
1946 }
1947 finally {
1948 closeSession(session);
1949 }
1950 }
1951
1952 return count.intValue();
1953 }
1954
1955 private static final String _FINDER_COLUMN_FILEENTRYID_FILEENTRYID_2 = "dlFileVersion.fileEntryId = ?";
1956 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_MIMETYPE = new FinderPath(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
1957 DLFileVersionModelImpl.FINDER_CACHE_ENABLED,
1958 DLFileVersionImpl.class, FINDER_CLASS_NAME_LIST_WITH_PAGINATION,
1959 "findByMimeType",
1960 new String[] {
1961 String.class.getName(),
1962
1963 Integer.class.getName(), Integer.class.getName(),
1964 OrderByComparator.class.getName()
1965 });
1966 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_MIMETYPE =
1967 new FinderPath(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
1968 DLFileVersionModelImpl.FINDER_CACHE_ENABLED,
1969 DLFileVersionImpl.class, FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION,
1970 "findByMimeType", new String[] { String.class.getName() },
1971 DLFileVersionModelImpl.MIMETYPE_COLUMN_BITMASK |
1972 DLFileVersionModelImpl.FILEENTRYID_COLUMN_BITMASK |
1973 DLFileVersionModelImpl.CREATEDATE_COLUMN_BITMASK);
1974 public static final FinderPath FINDER_PATH_COUNT_BY_MIMETYPE = new FinderPath(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
1975 DLFileVersionModelImpl.FINDER_CACHE_ENABLED, Long.class,
1976 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByMimeType",
1977 new String[] { String.class.getName() });
1978
1979
1986 @Override
1987 public List<DLFileVersion> findByMimeType(String mimeType)
1988 throws SystemException {
1989 return findByMimeType(mimeType, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
1990 null);
1991 }
1992
1993
2006 @Override
2007 public List<DLFileVersion> findByMimeType(String mimeType, int start,
2008 int end) throws SystemException {
2009 return findByMimeType(mimeType, start, end, null);
2010 }
2011
2012
2026 @Override
2027 public List<DLFileVersion> findByMimeType(String mimeType, int start,
2028 int end, OrderByComparator orderByComparator) throws SystemException {
2029 boolean pagination = true;
2030 FinderPath finderPath = null;
2031 Object[] finderArgs = null;
2032
2033 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
2034 (orderByComparator == null)) {
2035 pagination = false;
2036 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_MIMETYPE;
2037 finderArgs = new Object[] { mimeType };
2038 }
2039 else {
2040 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_MIMETYPE;
2041 finderArgs = new Object[] { mimeType, start, end, orderByComparator };
2042 }
2043
2044 List<DLFileVersion> list = (List<DLFileVersion>)FinderCacheUtil.getResult(finderPath,
2045 finderArgs, this);
2046
2047 if ((list != null) && !list.isEmpty()) {
2048 for (DLFileVersion dlFileVersion : list) {
2049 if (!Validator.equals(mimeType, dlFileVersion.getMimeType())) {
2050 list = null;
2051
2052 break;
2053 }
2054 }
2055 }
2056
2057 if (list == null) {
2058 StringBundler query = null;
2059
2060 if (orderByComparator != null) {
2061 query = new StringBundler(3 +
2062 (orderByComparator.getOrderByFields().length * 3));
2063 }
2064 else {
2065 query = new StringBundler(3);
2066 }
2067
2068 query.append(_SQL_SELECT_DLFILEVERSION_WHERE);
2069
2070 boolean bindMimeType = false;
2071
2072 if (mimeType == null) {
2073 query.append(_FINDER_COLUMN_MIMETYPE_MIMETYPE_1);
2074 }
2075 else if (mimeType.equals(StringPool.BLANK)) {
2076 query.append(_FINDER_COLUMN_MIMETYPE_MIMETYPE_3);
2077 }
2078 else {
2079 bindMimeType = true;
2080
2081 query.append(_FINDER_COLUMN_MIMETYPE_MIMETYPE_2);
2082 }
2083
2084 if (orderByComparator != null) {
2085 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2086 orderByComparator);
2087 }
2088 else
2089 if (pagination) {
2090 query.append(DLFileVersionModelImpl.ORDER_BY_JPQL);
2091 }
2092
2093 String sql = query.toString();
2094
2095 Session session = null;
2096
2097 try {
2098 session = openSession();
2099
2100 Query q = session.createQuery(sql);
2101
2102 QueryPos qPos = QueryPos.getInstance(q);
2103
2104 if (bindMimeType) {
2105 qPos.add(mimeType);
2106 }
2107
2108 if (!pagination) {
2109 list = (List<DLFileVersion>)QueryUtil.list(q, getDialect(),
2110 start, end, false);
2111
2112 Collections.sort(list);
2113
2114 list = new UnmodifiableList<DLFileVersion>(list);
2115 }
2116 else {
2117 list = (List<DLFileVersion>)QueryUtil.list(q, getDialect(),
2118 start, end);
2119 }
2120
2121 cacheResult(list);
2122
2123 FinderCacheUtil.putResult(finderPath, finderArgs, list);
2124 }
2125 catch (Exception e) {
2126 FinderCacheUtil.removeResult(finderPath, finderArgs);
2127
2128 throw processException(e);
2129 }
2130 finally {
2131 closeSession(session);
2132 }
2133 }
2134
2135 return list;
2136 }
2137
2138
2147 @Override
2148 public DLFileVersion findByMimeType_First(String mimeType,
2149 OrderByComparator orderByComparator)
2150 throws NoSuchFileVersionException, SystemException {
2151 DLFileVersion dlFileVersion = fetchByMimeType_First(mimeType,
2152 orderByComparator);
2153
2154 if (dlFileVersion != null) {
2155 return dlFileVersion;
2156 }
2157
2158 StringBundler msg = new StringBundler(4);
2159
2160 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2161
2162 msg.append("mimeType=");
2163 msg.append(mimeType);
2164
2165 msg.append(StringPool.CLOSE_CURLY_BRACE);
2166
2167 throw new NoSuchFileVersionException(msg.toString());
2168 }
2169
2170
2178 @Override
2179 public DLFileVersion fetchByMimeType_First(String mimeType,
2180 OrderByComparator orderByComparator) throws SystemException {
2181 List<DLFileVersion> list = findByMimeType(mimeType, 0, 1,
2182 orderByComparator);
2183
2184 if (!list.isEmpty()) {
2185 return list.get(0);
2186 }
2187
2188 return null;
2189 }
2190
2191
2200 @Override
2201 public DLFileVersion findByMimeType_Last(String mimeType,
2202 OrderByComparator orderByComparator)
2203 throws NoSuchFileVersionException, SystemException {
2204 DLFileVersion dlFileVersion = fetchByMimeType_Last(mimeType,
2205 orderByComparator);
2206
2207 if (dlFileVersion != null) {
2208 return dlFileVersion;
2209 }
2210
2211 StringBundler msg = new StringBundler(4);
2212
2213 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2214
2215 msg.append("mimeType=");
2216 msg.append(mimeType);
2217
2218 msg.append(StringPool.CLOSE_CURLY_BRACE);
2219
2220 throw new NoSuchFileVersionException(msg.toString());
2221 }
2222
2223
2231 @Override
2232 public DLFileVersion fetchByMimeType_Last(String mimeType,
2233 OrderByComparator orderByComparator) throws SystemException {
2234 int count = countByMimeType(mimeType);
2235
2236 if (count == 0) {
2237 return null;
2238 }
2239
2240 List<DLFileVersion> list = findByMimeType(mimeType, count - 1, count,
2241 orderByComparator);
2242
2243 if (!list.isEmpty()) {
2244 return list.get(0);
2245 }
2246
2247 return null;
2248 }
2249
2250
2260 @Override
2261 public DLFileVersion[] findByMimeType_PrevAndNext(long fileVersionId,
2262 String mimeType, OrderByComparator orderByComparator)
2263 throws NoSuchFileVersionException, SystemException {
2264 DLFileVersion dlFileVersion = findByPrimaryKey(fileVersionId);
2265
2266 Session session = null;
2267
2268 try {
2269 session = openSession();
2270
2271 DLFileVersion[] array = new DLFileVersionImpl[3];
2272
2273 array[0] = getByMimeType_PrevAndNext(session, dlFileVersion,
2274 mimeType, orderByComparator, true);
2275
2276 array[1] = dlFileVersion;
2277
2278 array[2] = getByMimeType_PrevAndNext(session, dlFileVersion,
2279 mimeType, orderByComparator, false);
2280
2281 return array;
2282 }
2283 catch (Exception e) {
2284 throw processException(e);
2285 }
2286 finally {
2287 closeSession(session);
2288 }
2289 }
2290
2291 protected DLFileVersion getByMimeType_PrevAndNext(Session session,
2292 DLFileVersion dlFileVersion, String mimeType,
2293 OrderByComparator orderByComparator, boolean previous) {
2294 StringBundler query = null;
2295
2296 if (orderByComparator != null) {
2297 query = new StringBundler(6 +
2298 (orderByComparator.getOrderByFields().length * 6));
2299 }
2300 else {
2301 query = new StringBundler(3);
2302 }
2303
2304 query.append(_SQL_SELECT_DLFILEVERSION_WHERE);
2305
2306 boolean bindMimeType = false;
2307
2308 if (mimeType == null) {
2309 query.append(_FINDER_COLUMN_MIMETYPE_MIMETYPE_1);
2310 }
2311 else if (mimeType.equals(StringPool.BLANK)) {
2312 query.append(_FINDER_COLUMN_MIMETYPE_MIMETYPE_3);
2313 }
2314 else {
2315 bindMimeType = true;
2316
2317 query.append(_FINDER_COLUMN_MIMETYPE_MIMETYPE_2);
2318 }
2319
2320 if (orderByComparator != null) {
2321 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
2322
2323 if (orderByConditionFields.length > 0) {
2324 query.append(WHERE_AND);
2325 }
2326
2327 for (int i = 0; i < orderByConditionFields.length; i++) {
2328 query.append(_ORDER_BY_ENTITY_ALIAS);
2329 query.append(orderByConditionFields[i]);
2330
2331 if ((i + 1) < orderByConditionFields.length) {
2332 if (orderByComparator.isAscending() ^ previous) {
2333 query.append(WHERE_GREATER_THAN_HAS_NEXT);
2334 }
2335 else {
2336 query.append(WHERE_LESSER_THAN_HAS_NEXT);
2337 }
2338 }
2339 else {
2340 if (orderByComparator.isAscending() ^ previous) {
2341 query.append(WHERE_GREATER_THAN);
2342 }
2343 else {
2344 query.append(WHERE_LESSER_THAN);
2345 }
2346 }
2347 }
2348
2349 query.append(ORDER_BY_CLAUSE);
2350
2351 String[] orderByFields = orderByComparator.getOrderByFields();
2352
2353 for (int i = 0; i < orderByFields.length; i++) {
2354 query.append(_ORDER_BY_ENTITY_ALIAS);
2355 query.append(orderByFields[i]);
2356
2357 if ((i + 1) < orderByFields.length) {
2358 if (orderByComparator.isAscending() ^ previous) {
2359 query.append(ORDER_BY_ASC_HAS_NEXT);
2360 }
2361 else {
2362 query.append(ORDER_BY_DESC_HAS_NEXT);
2363 }
2364 }
2365 else {
2366 if (orderByComparator.isAscending() ^ previous) {
2367 query.append(ORDER_BY_ASC);
2368 }
2369 else {
2370 query.append(ORDER_BY_DESC);
2371 }
2372 }
2373 }
2374 }
2375 else {
2376 query.append(DLFileVersionModelImpl.ORDER_BY_JPQL);
2377 }
2378
2379 String sql = query.toString();
2380
2381 Query q = session.createQuery(sql);
2382
2383 q.setFirstResult(0);
2384 q.setMaxResults(2);
2385
2386 QueryPos qPos = QueryPos.getInstance(q);
2387
2388 if (bindMimeType) {
2389 qPos.add(mimeType);
2390 }
2391
2392 if (orderByComparator != null) {
2393 Object[] values = orderByComparator.getOrderByConditionValues(dlFileVersion);
2394
2395 for (Object value : values) {
2396 qPos.add(value);
2397 }
2398 }
2399
2400 List<DLFileVersion> list = q.list();
2401
2402 if (list.size() == 2) {
2403 return list.get(1);
2404 }
2405 else {
2406 return null;
2407 }
2408 }
2409
2410
2416 @Override
2417 public void removeByMimeType(String mimeType) throws SystemException {
2418 for (DLFileVersion dlFileVersion : findByMimeType(mimeType,
2419 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
2420 remove(dlFileVersion);
2421 }
2422 }
2423
2424
2431 @Override
2432 public int countByMimeType(String mimeType) throws SystemException {
2433 FinderPath finderPath = FINDER_PATH_COUNT_BY_MIMETYPE;
2434
2435 Object[] finderArgs = new Object[] { mimeType };
2436
2437 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
2438 this);
2439
2440 if (count == null) {
2441 StringBundler query = new StringBundler(2);
2442
2443 query.append(_SQL_COUNT_DLFILEVERSION_WHERE);
2444
2445 boolean bindMimeType = false;
2446
2447 if (mimeType == null) {
2448 query.append(_FINDER_COLUMN_MIMETYPE_MIMETYPE_1);
2449 }
2450 else if (mimeType.equals(StringPool.BLANK)) {
2451 query.append(_FINDER_COLUMN_MIMETYPE_MIMETYPE_3);
2452 }
2453 else {
2454 bindMimeType = true;
2455
2456 query.append(_FINDER_COLUMN_MIMETYPE_MIMETYPE_2);
2457 }
2458
2459 String sql = query.toString();
2460
2461 Session session = null;
2462
2463 try {
2464 session = openSession();
2465
2466 Query q = session.createQuery(sql);
2467
2468 QueryPos qPos = QueryPos.getInstance(q);
2469
2470 if (bindMimeType) {
2471 qPos.add(mimeType);
2472 }
2473
2474 count = (Long)q.uniqueResult();
2475
2476 FinderCacheUtil.putResult(finderPath, finderArgs, count);
2477 }
2478 catch (Exception e) {
2479 FinderCacheUtil.removeResult(finderPath, finderArgs);
2480
2481 throw processException(e);
2482 }
2483 finally {
2484 closeSession(session);
2485 }
2486 }
2487
2488 return count.intValue();
2489 }
2490
2491 private static final String _FINDER_COLUMN_MIMETYPE_MIMETYPE_1 = "dlFileVersion.mimeType IS NULL";
2492 private static final String _FINDER_COLUMN_MIMETYPE_MIMETYPE_2 = "dlFileVersion.mimeType = ?";
2493 private static final String _FINDER_COLUMN_MIMETYPE_MIMETYPE_3 = "(dlFileVersion.mimeType IS NULL OR dlFileVersion.mimeType = '')";
2494 public static final FinderPath FINDER_PATH_FETCH_BY_F_V = new FinderPath(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
2495 DLFileVersionModelImpl.FINDER_CACHE_ENABLED,
2496 DLFileVersionImpl.class, FINDER_CLASS_NAME_ENTITY, "fetchByF_V",
2497 new String[] { Long.class.getName(), String.class.getName() },
2498 DLFileVersionModelImpl.FILEENTRYID_COLUMN_BITMASK |
2499 DLFileVersionModelImpl.VERSION_COLUMN_BITMASK);
2500 public static final FinderPath FINDER_PATH_COUNT_BY_F_V = new FinderPath(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
2501 DLFileVersionModelImpl.FINDER_CACHE_ENABLED, Long.class,
2502 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByF_V",
2503 new String[] { Long.class.getName(), String.class.getName() });
2504
2505
2514 @Override
2515 public DLFileVersion findByF_V(long fileEntryId, String version)
2516 throws NoSuchFileVersionException, SystemException {
2517 DLFileVersion dlFileVersion = fetchByF_V(fileEntryId, version);
2518
2519 if (dlFileVersion == null) {
2520 StringBundler msg = new StringBundler(6);
2521
2522 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2523
2524 msg.append("fileEntryId=");
2525 msg.append(fileEntryId);
2526
2527 msg.append(", version=");
2528 msg.append(version);
2529
2530 msg.append(StringPool.CLOSE_CURLY_BRACE);
2531
2532 if (_log.isWarnEnabled()) {
2533 _log.warn(msg.toString());
2534 }
2535
2536 throw new NoSuchFileVersionException(msg.toString());
2537 }
2538
2539 return dlFileVersion;
2540 }
2541
2542
2550 @Override
2551 public DLFileVersion fetchByF_V(long fileEntryId, String version)
2552 throws SystemException {
2553 return fetchByF_V(fileEntryId, version, true);
2554 }
2555
2556
2565 @Override
2566 public DLFileVersion fetchByF_V(long fileEntryId, String version,
2567 boolean retrieveFromCache) throws SystemException {
2568 Object[] finderArgs = new Object[] { fileEntryId, version };
2569
2570 Object result = null;
2571
2572 if (retrieveFromCache) {
2573 result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_F_V,
2574 finderArgs, this);
2575 }
2576
2577 if (result instanceof DLFileVersion) {
2578 DLFileVersion dlFileVersion = (DLFileVersion)result;
2579
2580 if ((fileEntryId != dlFileVersion.getFileEntryId()) ||
2581 !Validator.equals(version, dlFileVersion.getVersion())) {
2582 result = null;
2583 }
2584 }
2585
2586 if (result == null) {
2587 StringBundler query = new StringBundler(4);
2588
2589 query.append(_SQL_SELECT_DLFILEVERSION_WHERE);
2590
2591 query.append(_FINDER_COLUMN_F_V_FILEENTRYID_2);
2592
2593 boolean bindVersion = false;
2594
2595 if (version == null) {
2596 query.append(_FINDER_COLUMN_F_V_VERSION_1);
2597 }
2598 else if (version.equals(StringPool.BLANK)) {
2599 query.append(_FINDER_COLUMN_F_V_VERSION_3);
2600 }
2601 else {
2602 bindVersion = true;
2603
2604 query.append(_FINDER_COLUMN_F_V_VERSION_2);
2605 }
2606
2607 String sql = query.toString();
2608
2609 Session session = null;
2610
2611 try {
2612 session = openSession();
2613
2614 Query q = session.createQuery(sql);
2615
2616 QueryPos qPos = QueryPos.getInstance(q);
2617
2618 qPos.add(fileEntryId);
2619
2620 if (bindVersion) {
2621 qPos.add(version);
2622 }
2623
2624 List<DLFileVersion> list = q.list();
2625
2626 if (list.isEmpty()) {
2627 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_F_V,
2628 finderArgs, list);
2629 }
2630 else {
2631 DLFileVersion dlFileVersion = list.get(0);
2632
2633 result = dlFileVersion;
2634
2635 cacheResult(dlFileVersion);
2636
2637 if ((dlFileVersion.getFileEntryId() != fileEntryId) ||
2638 (dlFileVersion.getVersion() == null) ||
2639 !dlFileVersion.getVersion().equals(version)) {
2640 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_F_V,
2641 finderArgs, dlFileVersion);
2642 }
2643 }
2644 }
2645 catch (Exception e) {
2646 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_F_V,
2647 finderArgs);
2648
2649 throw processException(e);
2650 }
2651 finally {
2652 closeSession(session);
2653 }
2654 }
2655
2656 if (result instanceof List<?>) {
2657 return null;
2658 }
2659 else {
2660 return (DLFileVersion)result;
2661 }
2662 }
2663
2664
2672 @Override
2673 public DLFileVersion removeByF_V(long fileEntryId, String version)
2674 throws NoSuchFileVersionException, SystemException {
2675 DLFileVersion dlFileVersion = findByF_V(fileEntryId, version);
2676
2677 return remove(dlFileVersion);
2678 }
2679
2680
2688 @Override
2689 public int countByF_V(long fileEntryId, String version)
2690 throws SystemException {
2691 FinderPath finderPath = FINDER_PATH_COUNT_BY_F_V;
2692
2693 Object[] finderArgs = new Object[] { fileEntryId, version };
2694
2695 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
2696 this);
2697
2698 if (count == null) {
2699 StringBundler query = new StringBundler(3);
2700
2701 query.append(_SQL_COUNT_DLFILEVERSION_WHERE);
2702
2703 query.append(_FINDER_COLUMN_F_V_FILEENTRYID_2);
2704
2705 boolean bindVersion = false;
2706
2707 if (version == null) {
2708 query.append(_FINDER_COLUMN_F_V_VERSION_1);
2709 }
2710 else if (version.equals(StringPool.BLANK)) {
2711 query.append(_FINDER_COLUMN_F_V_VERSION_3);
2712 }
2713 else {
2714 bindVersion = true;
2715
2716 query.append(_FINDER_COLUMN_F_V_VERSION_2);
2717 }
2718
2719 String sql = query.toString();
2720
2721 Session session = null;
2722
2723 try {
2724 session = openSession();
2725
2726 Query q = session.createQuery(sql);
2727
2728 QueryPos qPos = QueryPos.getInstance(q);
2729
2730 qPos.add(fileEntryId);
2731
2732 if (bindVersion) {
2733 qPos.add(version);
2734 }
2735
2736 count = (Long)q.uniqueResult();
2737
2738 FinderCacheUtil.putResult(finderPath, finderArgs, count);
2739 }
2740 catch (Exception e) {
2741 FinderCacheUtil.removeResult(finderPath, finderArgs);
2742
2743 throw processException(e);
2744 }
2745 finally {
2746 closeSession(session);
2747 }
2748 }
2749
2750 return count.intValue();
2751 }
2752
2753 private static final String _FINDER_COLUMN_F_V_FILEENTRYID_2 = "dlFileVersion.fileEntryId = ? AND ";
2754 private static final String _FINDER_COLUMN_F_V_VERSION_1 = "dlFileVersion.version IS NULL";
2755 private static final String _FINDER_COLUMN_F_V_VERSION_2 = "dlFileVersion.version = ?";
2756 private static final String _FINDER_COLUMN_F_V_VERSION_3 = "(dlFileVersion.version IS NULL OR dlFileVersion.version = '')";
2757 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_F_S = new FinderPath(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
2758 DLFileVersionModelImpl.FINDER_CACHE_ENABLED,
2759 DLFileVersionImpl.class, FINDER_CLASS_NAME_LIST_WITH_PAGINATION,
2760 "findByF_S",
2761 new String[] {
2762 Long.class.getName(), Integer.class.getName(),
2763
2764 Integer.class.getName(), Integer.class.getName(),
2765 OrderByComparator.class.getName()
2766 });
2767 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_F_S = new FinderPath(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
2768 DLFileVersionModelImpl.FINDER_CACHE_ENABLED,
2769 DLFileVersionImpl.class, FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION,
2770 "findByF_S",
2771 new String[] { Long.class.getName(), Integer.class.getName() },
2772 DLFileVersionModelImpl.FILEENTRYID_COLUMN_BITMASK |
2773 DLFileVersionModelImpl.STATUS_COLUMN_BITMASK |
2774 DLFileVersionModelImpl.CREATEDATE_COLUMN_BITMASK);
2775 public static final FinderPath FINDER_PATH_COUNT_BY_F_S = new FinderPath(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
2776 DLFileVersionModelImpl.FINDER_CACHE_ENABLED, Long.class,
2777 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByF_S",
2778 new String[] { Long.class.getName(), Integer.class.getName() });
2779
2780
2788 @Override
2789 public List<DLFileVersion> findByF_S(long fileEntryId, int status)
2790 throws SystemException {
2791 return findByF_S(fileEntryId, status, QueryUtil.ALL_POS,
2792 QueryUtil.ALL_POS, null);
2793 }
2794
2795
2809 @Override
2810 public List<DLFileVersion> findByF_S(long fileEntryId, int status,
2811 int start, int end) throws SystemException {
2812 return findByF_S(fileEntryId, status, start, end, null);
2813 }
2814
2815
2830 @Override
2831 public List<DLFileVersion> findByF_S(long fileEntryId, int status,
2832 int start, int end, OrderByComparator orderByComparator)
2833 throws SystemException {
2834 boolean pagination = true;
2835 FinderPath finderPath = null;
2836 Object[] finderArgs = null;
2837
2838 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
2839 (orderByComparator == null)) {
2840 pagination = false;
2841 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_F_S;
2842 finderArgs = new Object[] { fileEntryId, status };
2843 }
2844 else {
2845 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_F_S;
2846 finderArgs = new Object[] {
2847 fileEntryId, status,
2848
2849 start, end, orderByComparator
2850 };
2851 }
2852
2853 List<DLFileVersion> list = (List<DLFileVersion>)FinderCacheUtil.getResult(finderPath,
2854 finderArgs, this);
2855
2856 if ((list != null) && !list.isEmpty()) {
2857 for (DLFileVersion dlFileVersion : list) {
2858 if ((fileEntryId != dlFileVersion.getFileEntryId()) ||
2859 (status != dlFileVersion.getStatus())) {
2860 list = null;
2861
2862 break;
2863 }
2864 }
2865 }
2866
2867 if (list == null) {
2868 StringBundler query = null;
2869
2870 if (orderByComparator != null) {
2871 query = new StringBundler(4 +
2872 (orderByComparator.getOrderByFields().length * 3));
2873 }
2874 else {
2875 query = new StringBundler(4);
2876 }
2877
2878 query.append(_SQL_SELECT_DLFILEVERSION_WHERE);
2879
2880 query.append(_FINDER_COLUMN_F_S_FILEENTRYID_2);
2881
2882 query.append(_FINDER_COLUMN_F_S_STATUS_2);
2883
2884 if (orderByComparator != null) {
2885 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2886 orderByComparator);
2887 }
2888 else
2889 if (pagination) {
2890 query.append(DLFileVersionModelImpl.ORDER_BY_JPQL);
2891 }
2892
2893 String sql = query.toString();
2894
2895 Session session = null;
2896
2897 try {
2898 session = openSession();
2899
2900 Query q = session.createQuery(sql);
2901
2902 QueryPos qPos = QueryPos.getInstance(q);
2903
2904 qPos.add(fileEntryId);
2905
2906 qPos.add(status);
2907
2908 if (!pagination) {
2909 list = (List<DLFileVersion>)QueryUtil.list(q, getDialect(),
2910 start, end, false);
2911
2912 Collections.sort(list);
2913
2914 list = new UnmodifiableList<DLFileVersion>(list);
2915 }
2916 else {
2917 list = (List<DLFileVersion>)QueryUtil.list(q, getDialect(),
2918 start, end);
2919 }
2920
2921 cacheResult(list);
2922
2923 FinderCacheUtil.putResult(finderPath, finderArgs, list);
2924 }
2925 catch (Exception e) {
2926 FinderCacheUtil.removeResult(finderPath, finderArgs);
2927
2928 throw processException(e);
2929 }
2930 finally {
2931 closeSession(session);
2932 }
2933 }
2934
2935 return list;
2936 }
2937
2938
2948 @Override
2949 public DLFileVersion findByF_S_First(long fileEntryId, int status,
2950 OrderByComparator orderByComparator)
2951 throws NoSuchFileVersionException, SystemException {
2952 DLFileVersion dlFileVersion = fetchByF_S_First(fileEntryId, status,
2953 orderByComparator);
2954
2955 if (dlFileVersion != null) {
2956 return dlFileVersion;
2957 }
2958
2959 StringBundler msg = new StringBundler(6);
2960
2961 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2962
2963 msg.append("fileEntryId=");
2964 msg.append(fileEntryId);
2965
2966 msg.append(", status=");
2967 msg.append(status);
2968
2969 msg.append(StringPool.CLOSE_CURLY_BRACE);
2970
2971 throw new NoSuchFileVersionException(msg.toString());
2972 }
2973
2974
2983 @Override
2984 public DLFileVersion fetchByF_S_First(long fileEntryId, int status,
2985 OrderByComparator orderByComparator) throws SystemException {
2986 List<DLFileVersion> list = findByF_S(fileEntryId, status, 0, 1,
2987 orderByComparator);
2988
2989 if (!list.isEmpty()) {
2990 return list.get(0);
2991 }
2992
2993 return null;
2994 }
2995
2996
3006 @Override
3007 public DLFileVersion findByF_S_Last(long fileEntryId, int status,
3008 OrderByComparator orderByComparator)
3009 throws NoSuchFileVersionException, SystemException {
3010 DLFileVersion dlFileVersion = fetchByF_S_Last(fileEntryId, status,
3011 orderByComparator);
3012
3013 if (dlFileVersion != null) {
3014 return dlFileVersion;
3015 }
3016
3017 StringBundler msg = new StringBundler(6);
3018
3019 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3020
3021 msg.append("fileEntryId=");
3022 msg.append(fileEntryId);
3023
3024 msg.append(", status=");
3025 msg.append(status);
3026
3027 msg.append(StringPool.CLOSE_CURLY_BRACE);
3028
3029 throw new NoSuchFileVersionException(msg.toString());
3030 }
3031
3032
3041 @Override
3042 public DLFileVersion fetchByF_S_Last(long fileEntryId, int status,
3043 OrderByComparator orderByComparator) throws SystemException {
3044 int count = countByF_S(fileEntryId, status);
3045
3046 if (count == 0) {
3047 return null;
3048 }
3049
3050 List<DLFileVersion> list = findByF_S(fileEntryId, status, count - 1,
3051 count, orderByComparator);
3052
3053 if (!list.isEmpty()) {
3054 return list.get(0);
3055 }
3056
3057 return null;
3058 }
3059
3060
3071 @Override
3072 public DLFileVersion[] findByF_S_PrevAndNext(long fileVersionId,
3073 long fileEntryId, int status, OrderByComparator orderByComparator)
3074 throws NoSuchFileVersionException, SystemException {
3075 DLFileVersion dlFileVersion = findByPrimaryKey(fileVersionId);
3076
3077 Session session = null;
3078
3079 try {
3080 session = openSession();
3081
3082 DLFileVersion[] array = new DLFileVersionImpl[3];
3083
3084 array[0] = getByF_S_PrevAndNext(session, dlFileVersion,
3085 fileEntryId, status, orderByComparator, true);
3086
3087 array[1] = dlFileVersion;
3088
3089 array[2] = getByF_S_PrevAndNext(session, dlFileVersion,
3090 fileEntryId, status, orderByComparator, false);
3091
3092 return array;
3093 }
3094 catch (Exception e) {
3095 throw processException(e);
3096 }
3097 finally {
3098 closeSession(session);
3099 }
3100 }
3101
3102 protected DLFileVersion getByF_S_PrevAndNext(Session session,
3103 DLFileVersion dlFileVersion, long fileEntryId, int status,
3104 OrderByComparator orderByComparator, boolean previous) {
3105 StringBundler query = null;
3106
3107 if (orderByComparator != null) {
3108 query = new StringBundler(6 +
3109 (orderByComparator.getOrderByFields().length * 6));
3110 }
3111 else {
3112 query = new StringBundler(3);
3113 }
3114
3115 query.append(_SQL_SELECT_DLFILEVERSION_WHERE);
3116
3117 query.append(_FINDER_COLUMN_F_S_FILEENTRYID_2);
3118
3119 query.append(_FINDER_COLUMN_F_S_STATUS_2);
3120
3121 if (orderByComparator != null) {
3122 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
3123
3124 if (orderByConditionFields.length > 0) {
3125 query.append(WHERE_AND);
3126 }
3127
3128 for (int i = 0; i < orderByConditionFields.length; i++) {
3129 query.append(_ORDER_BY_ENTITY_ALIAS);
3130 query.append(orderByConditionFields[i]);
3131
3132 if ((i + 1) < orderByConditionFields.length) {
3133 if (orderByComparator.isAscending() ^ previous) {
3134 query.append(WHERE_GREATER_THAN_HAS_NEXT);
3135 }
3136 else {
3137 query.append(WHERE_LESSER_THAN_HAS_NEXT);
3138 }
3139 }
3140 else {
3141 if (orderByComparator.isAscending() ^ previous) {
3142 query.append(WHERE_GREATER_THAN);
3143 }
3144 else {
3145 query.append(WHERE_LESSER_THAN);
3146 }
3147 }
3148 }
3149
3150 query.append(ORDER_BY_CLAUSE);
3151
3152 String[] orderByFields = orderByComparator.getOrderByFields();
3153
3154 for (int i = 0; i < orderByFields.length; i++) {
3155 query.append(_ORDER_BY_ENTITY_ALIAS);
3156 query.append(orderByFields[i]);
3157
3158 if ((i + 1) < orderByFields.length) {
3159 if (orderByComparator.isAscending() ^ previous) {
3160 query.append(ORDER_BY_ASC_HAS_NEXT);
3161 }
3162 else {
3163 query.append(ORDER_BY_DESC_HAS_NEXT);
3164 }
3165 }
3166 else {
3167 if (orderByComparator.isAscending() ^ previous) {
3168 query.append(ORDER_BY_ASC);
3169 }
3170 else {
3171 query.append(ORDER_BY_DESC);
3172 }
3173 }
3174 }
3175 }
3176 else {
3177 query.append(DLFileVersionModelImpl.ORDER_BY_JPQL);
3178 }
3179
3180 String sql = query.toString();
3181
3182 Query q = session.createQuery(sql);
3183
3184 q.setFirstResult(0);
3185 q.setMaxResults(2);
3186
3187 QueryPos qPos = QueryPos.getInstance(q);
3188
3189 qPos.add(fileEntryId);
3190
3191 qPos.add(status);
3192
3193 if (orderByComparator != null) {
3194 Object[] values = orderByComparator.getOrderByConditionValues(dlFileVersion);
3195
3196 for (Object value : values) {
3197 qPos.add(value);
3198 }
3199 }
3200
3201 List<DLFileVersion> list = q.list();
3202
3203 if (list.size() == 2) {
3204 return list.get(1);
3205 }
3206 else {
3207 return null;
3208 }
3209 }
3210
3211
3218 @Override
3219 public void removeByF_S(long fileEntryId, int status)
3220 throws SystemException {
3221 for (DLFileVersion dlFileVersion : findByF_S(fileEntryId, status,
3222 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
3223 remove(dlFileVersion);
3224 }
3225 }
3226
3227
3235 @Override
3236 public int countByF_S(long fileEntryId, int status)
3237 throws SystemException {
3238 FinderPath finderPath = FINDER_PATH_COUNT_BY_F_S;
3239
3240 Object[] finderArgs = new Object[] { fileEntryId, status };
3241
3242 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
3243 this);
3244
3245 if (count == null) {
3246 StringBundler query = new StringBundler(3);
3247
3248 query.append(_SQL_COUNT_DLFILEVERSION_WHERE);
3249
3250 query.append(_FINDER_COLUMN_F_S_FILEENTRYID_2);
3251
3252 query.append(_FINDER_COLUMN_F_S_STATUS_2);
3253
3254 String sql = query.toString();
3255
3256 Session session = null;
3257
3258 try {
3259 session = openSession();
3260
3261 Query q = session.createQuery(sql);
3262
3263 QueryPos qPos = QueryPos.getInstance(q);
3264
3265 qPos.add(fileEntryId);
3266
3267 qPos.add(status);
3268
3269 count = (Long)q.uniqueResult();
3270
3271 FinderCacheUtil.putResult(finderPath, finderArgs, count);
3272 }
3273 catch (Exception e) {
3274 FinderCacheUtil.removeResult(finderPath, finderArgs);
3275
3276 throw processException(e);
3277 }
3278 finally {
3279 closeSession(session);
3280 }
3281 }
3282
3283 return count.intValue();
3284 }
3285
3286 private static final String _FINDER_COLUMN_F_S_FILEENTRYID_2 = "dlFileVersion.fileEntryId = ? AND ";
3287 private static final String _FINDER_COLUMN_F_S_STATUS_2 = "dlFileVersion.status = ?";
3288 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_G_F_S = new FinderPath(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
3289 DLFileVersionModelImpl.FINDER_CACHE_ENABLED,
3290 DLFileVersionImpl.class, FINDER_CLASS_NAME_LIST_WITH_PAGINATION,
3291 "findByG_F_S",
3292 new String[] {
3293 Long.class.getName(), Long.class.getName(),
3294 Integer.class.getName(),
3295
3296 Integer.class.getName(), Integer.class.getName(),
3297 OrderByComparator.class.getName()
3298 });
3299 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_G_F_S = new FinderPath(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
3300 DLFileVersionModelImpl.FINDER_CACHE_ENABLED,
3301 DLFileVersionImpl.class, FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION,
3302 "findByG_F_S",
3303 new String[] {
3304 Long.class.getName(), Long.class.getName(),
3305 Integer.class.getName()
3306 },
3307 DLFileVersionModelImpl.GROUPID_COLUMN_BITMASK |
3308 DLFileVersionModelImpl.FOLDERID_COLUMN_BITMASK |
3309 DLFileVersionModelImpl.STATUS_COLUMN_BITMASK |
3310 DLFileVersionModelImpl.FILEENTRYID_COLUMN_BITMASK |
3311 DLFileVersionModelImpl.CREATEDATE_COLUMN_BITMASK);
3312 public static final FinderPath FINDER_PATH_COUNT_BY_G_F_S = new FinderPath(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
3313 DLFileVersionModelImpl.FINDER_CACHE_ENABLED, Long.class,
3314 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByG_F_S",
3315 new String[] {
3316 Long.class.getName(), Long.class.getName(),
3317 Integer.class.getName()
3318 });
3319
3320
3329 @Override
3330 public List<DLFileVersion> findByG_F_S(long groupId, long folderId,
3331 int status) throws SystemException {
3332 return findByG_F_S(groupId, folderId, status, QueryUtil.ALL_POS,
3333 QueryUtil.ALL_POS, null);
3334 }
3335
3336
3351 @Override
3352 public List<DLFileVersion> findByG_F_S(long groupId, long folderId,
3353 int status, int start, int end) throws SystemException {
3354 return findByG_F_S(groupId, folderId, status, start, end, null);
3355 }
3356
3357
3373 @Override
3374 public List<DLFileVersion> findByG_F_S(long groupId, long folderId,
3375 int status, int start, int end, OrderByComparator orderByComparator)
3376 throws SystemException {
3377 boolean pagination = true;
3378 FinderPath finderPath = null;
3379 Object[] finderArgs = null;
3380
3381 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
3382 (orderByComparator == null)) {
3383 pagination = false;
3384 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_G_F_S;
3385 finderArgs = new Object[] { groupId, folderId, status };
3386 }
3387 else {
3388 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_G_F_S;
3389 finderArgs = new Object[] {
3390 groupId, folderId, status,
3391
3392 start, end, orderByComparator
3393 };
3394 }
3395
3396 List<DLFileVersion> list = (List<DLFileVersion>)FinderCacheUtil.getResult(finderPath,
3397 finderArgs, this);
3398
3399 if ((list != null) && !list.isEmpty()) {
3400 for (DLFileVersion dlFileVersion : list) {
3401 if ((groupId != dlFileVersion.getGroupId()) ||
3402 (folderId != dlFileVersion.getFolderId()) ||
3403 (status != dlFileVersion.getStatus())) {
3404 list = null;
3405
3406 break;
3407 }
3408 }
3409 }
3410
3411 if (list == null) {
3412 StringBundler query = null;
3413
3414 if (orderByComparator != null) {
3415 query = new StringBundler(5 +
3416 (orderByComparator.getOrderByFields().length * 3));
3417 }
3418 else {
3419 query = new StringBundler(5);
3420 }
3421
3422 query.append(_SQL_SELECT_DLFILEVERSION_WHERE);
3423
3424 query.append(_FINDER_COLUMN_G_F_S_GROUPID_2);
3425
3426 query.append(_FINDER_COLUMN_G_F_S_FOLDERID_2);
3427
3428 query.append(_FINDER_COLUMN_G_F_S_STATUS_2);
3429
3430 if (orderByComparator != null) {
3431 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
3432 orderByComparator);
3433 }
3434 else
3435 if (pagination) {
3436 query.append(DLFileVersionModelImpl.ORDER_BY_JPQL);
3437 }
3438
3439 String sql = query.toString();
3440
3441 Session session = null;
3442
3443 try {
3444 session = openSession();
3445
3446 Query q = session.createQuery(sql);
3447
3448 QueryPos qPos = QueryPos.getInstance(q);
3449
3450 qPos.add(groupId);
3451
3452 qPos.add(folderId);
3453
3454 qPos.add(status);
3455
3456 if (!pagination) {
3457 list = (List<DLFileVersion>)QueryUtil.list(q, getDialect(),
3458 start, end, false);
3459
3460 Collections.sort(list);
3461
3462 list = new UnmodifiableList<DLFileVersion>(list);
3463 }
3464 else {
3465 list = (List<DLFileVersion>)QueryUtil.list(q, getDialect(),
3466 start, end);
3467 }
3468
3469 cacheResult(list);
3470
3471 FinderCacheUtil.putResult(finderPath, finderArgs, list);
3472 }
3473 catch (Exception e) {
3474 FinderCacheUtil.removeResult(finderPath, finderArgs);
3475
3476 throw processException(e);
3477 }
3478 finally {
3479 closeSession(session);
3480 }
3481 }
3482
3483 return list;
3484 }
3485
3486
3497 @Override
3498 public DLFileVersion findByG_F_S_First(long groupId, long folderId,
3499 int status, OrderByComparator orderByComparator)
3500 throws NoSuchFileVersionException, SystemException {
3501 DLFileVersion dlFileVersion = fetchByG_F_S_First(groupId, folderId,
3502 status, orderByComparator);
3503
3504 if (dlFileVersion != null) {
3505 return dlFileVersion;
3506 }
3507
3508 StringBundler msg = new StringBundler(8);
3509
3510 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3511
3512 msg.append("groupId=");
3513 msg.append(groupId);
3514
3515 msg.append(", folderId=");
3516 msg.append(folderId);
3517
3518 msg.append(", status=");
3519 msg.append(status);
3520
3521 msg.append(StringPool.CLOSE_CURLY_BRACE);
3522
3523 throw new NoSuchFileVersionException(msg.toString());
3524 }
3525
3526
3536 @Override
3537 public DLFileVersion fetchByG_F_S_First(long groupId, long folderId,
3538 int status, OrderByComparator orderByComparator)
3539 throws SystemException {
3540 List<DLFileVersion> list = findByG_F_S(groupId, folderId, status, 0, 1,
3541 orderByComparator);
3542
3543 if (!list.isEmpty()) {
3544 return list.get(0);
3545 }
3546
3547 return null;
3548 }
3549
3550
3561 @Override
3562 public DLFileVersion findByG_F_S_Last(long groupId, long folderId,
3563 int status, OrderByComparator orderByComparator)
3564 throws NoSuchFileVersionException, SystemException {
3565 DLFileVersion dlFileVersion = fetchByG_F_S_Last(groupId, folderId,
3566 status, orderByComparator);
3567
3568 if (dlFileVersion != null) {
3569 return dlFileVersion;
3570 }
3571
3572 StringBundler msg = new StringBundler(8);
3573
3574 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3575
3576 msg.append("groupId=");
3577 msg.append(groupId);
3578
3579 msg.append(", folderId=");
3580 msg.append(folderId);
3581
3582 msg.append(", status=");
3583 msg.append(status);
3584
3585 msg.append(StringPool.CLOSE_CURLY_BRACE);
3586
3587 throw new NoSuchFileVersionException(msg.toString());
3588 }
3589
3590
3600 @Override
3601 public DLFileVersion fetchByG_F_S_Last(long groupId, long folderId,
3602 int status, OrderByComparator orderByComparator)
3603 throws SystemException {
3604 int count = countByG_F_S(groupId, folderId, status);
3605
3606 if (count == 0) {
3607 return null;
3608 }
3609
3610 List<DLFileVersion> list = findByG_F_S(groupId, folderId, status,
3611 count - 1, count, orderByComparator);
3612
3613 if (!list.isEmpty()) {
3614 return list.get(0);
3615 }
3616
3617 return null;
3618 }
3619
3620
3632 @Override
3633 public DLFileVersion[] findByG_F_S_PrevAndNext(long fileVersionId,
3634 long groupId, long folderId, int status,
3635 OrderByComparator orderByComparator)
3636 throws NoSuchFileVersionException, SystemException {
3637 DLFileVersion dlFileVersion = findByPrimaryKey(fileVersionId);
3638
3639 Session session = null;
3640
3641 try {
3642 session = openSession();
3643
3644 DLFileVersion[] array = new DLFileVersionImpl[3];
3645
3646 array[0] = getByG_F_S_PrevAndNext(session, dlFileVersion, groupId,
3647 folderId, status, orderByComparator, true);
3648
3649 array[1] = dlFileVersion;
3650
3651 array[2] = getByG_F_S_PrevAndNext(session, dlFileVersion, groupId,
3652 folderId, status, orderByComparator, false);
3653
3654 return array;
3655 }
3656 catch (Exception e) {
3657 throw processException(e);
3658 }
3659 finally {
3660 closeSession(session);
3661 }
3662 }
3663
3664 protected DLFileVersion getByG_F_S_PrevAndNext(Session session,
3665 DLFileVersion dlFileVersion, long groupId, long folderId, int status,
3666 OrderByComparator orderByComparator, boolean previous) {
3667 StringBundler query = null;
3668
3669 if (orderByComparator != null) {
3670 query = new StringBundler(6 +
3671 (orderByComparator.getOrderByFields().length * 6));
3672 }
3673 else {
3674 query = new StringBundler(3);
3675 }
3676
3677 query.append(_SQL_SELECT_DLFILEVERSION_WHERE);
3678
3679 query.append(_FINDER_COLUMN_G_F_S_GROUPID_2);
3680
3681 query.append(_FINDER_COLUMN_G_F_S_FOLDERID_2);
3682
3683 query.append(_FINDER_COLUMN_G_F_S_STATUS_2);
3684
3685 if (orderByComparator != null) {
3686 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
3687
3688 if (orderByConditionFields.length > 0) {
3689 query.append(WHERE_AND);
3690 }
3691
3692 for (int i = 0; i < orderByConditionFields.length; i++) {
3693 query.append(_ORDER_BY_ENTITY_ALIAS);
3694 query.append(orderByConditionFields[i]);
3695
3696 if ((i + 1) < orderByConditionFields.length) {
3697 if (orderByComparator.isAscending() ^ previous) {
3698 query.append(WHERE_GREATER_THAN_HAS_NEXT);
3699 }
3700 else {
3701 query.append(WHERE_LESSER_THAN_HAS_NEXT);
3702 }
3703 }
3704 else {
3705 if (orderByComparator.isAscending() ^ previous) {
3706 query.append(WHERE_GREATER_THAN);
3707 }
3708 else {
3709 query.append(WHERE_LESSER_THAN);
3710 }
3711 }
3712 }
3713
3714 query.append(ORDER_BY_CLAUSE);
3715
3716 String[] orderByFields = orderByComparator.getOrderByFields();
3717
3718 for (int i = 0; i < orderByFields.length; i++) {
3719 query.append(_ORDER_BY_ENTITY_ALIAS);
3720 query.append(orderByFields[i]);
3721
3722 if ((i + 1) < orderByFields.length) {
3723 if (orderByComparator.isAscending() ^ previous) {
3724 query.append(ORDER_BY_ASC_HAS_NEXT);
3725 }
3726 else {
3727 query.append(ORDER_BY_DESC_HAS_NEXT);
3728 }
3729 }
3730 else {
3731 if (orderByComparator.isAscending() ^ previous) {
3732 query.append(ORDER_BY_ASC);
3733 }
3734 else {
3735 query.append(ORDER_BY_DESC);
3736 }
3737 }
3738 }
3739 }
3740 else {
3741 query.append(DLFileVersionModelImpl.ORDER_BY_JPQL);
3742 }
3743
3744 String sql = query.toString();
3745
3746 Query q = session.createQuery(sql);
3747
3748 q.setFirstResult(0);
3749 q.setMaxResults(2);
3750
3751 QueryPos qPos = QueryPos.getInstance(q);
3752
3753 qPos.add(groupId);
3754
3755 qPos.add(folderId);
3756
3757 qPos.add(status);
3758
3759 if (orderByComparator != null) {
3760 Object[] values = orderByComparator.getOrderByConditionValues(dlFileVersion);
3761
3762 for (Object value : values) {
3763 qPos.add(value);
3764 }
3765 }
3766
3767 List<DLFileVersion> list = q.list();
3768
3769 if (list.size() == 2) {
3770 return list.get(1);
3771 }
3772 else {
3773 return null;
3774 }
3775 }
3776
3777
3785 @Override
3786 public void removeByG_F_S(long groupId, long folderId, int status)
3787 throws SystemException {
3788 for (DLFileVersion dlFileVersion : findByG_F_S(groupId, folderId,
3789 status, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
3790 remove(dlFileVersion);
3791 }
3792 }
3793
3794
3803 @Override
3804 public int countByG_F_S(long groupId, long folderId, int status)
3805 throws SystemException {
3806 FinderPath finderPath = FINDER_PATH_COUNT_BY_G_F_S;
3807
3808 Object[] finderArgs = new Object[] { groupId, folderId, status };
3809
3810 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
3811 this);
3812
3813 if (count == null) {
3814 StringBundler query = new StringBundler(4);
3815
3816 query.append(_SQL_COUNT_DLFILEVERSION_WHERE);
3817
3818 query.append(_FINDER_COLUMN_G_F_S_GROUPID_2);
3819
3820 query.append(_FINDER_COLUMN_G_F_S_FOLDERID_2);
3821
3822 query.append(_FINDER_COLUMN_G_F_S_STATUS_2);
3823
3824 String sql = query.toString();
3825
3826 Session session = null;
3827
3828 try {
3829 session = openSession();
3830
3831 Query q = session.createQuery(sql);
3832
3833 QueryPos qPos = QueryPos.getInstance(q);
3834
3835 qPos.add(groupId);
3836
3837 qPos.add(folderId);
3838
3839 qPos.add(status);
3840
3841 count = (Long)q.uniqueResult();
3842
3843 FinderCacheUtil.putResult(finderPath, finderArgs, count);
3844 }
3845 catch (Exception e) {
3846 FinderCacheUtil.removeResult(finderPath, finderArgs);
3847
3848 throw processException(e);
3849 }
3850 finally {
3851 closeSession(session);
3852 }
3853 }
3854
3855 return count.intValue();
3856 }
3857
3858 private static final String _FINDER_COLUMN_G_F_S_GROUPID_2 = "dlFileVersion.groupId = ? AND ";
3859 private static final String _FINDER_COLUMN_G_F_S_FOLDERID_2 = "dlFileVersion.folderId = ? AND ";
3860 private static final String _FINDER_COLUMN_G_F_S_STATUS_2 = "dlFileVersion.status = ?";
3861 public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_G_F_T_V = new FinderPath(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
3862 DLFileVersionModelImpl.FINDER_CACHE_ENABLED,
3863 DLFileVersionImpl.class, FINDER_CLASS_NAME_LIST_WITH_PAGINATION,
3864 "findByG_F_T_V",
3865 new String[] {
3866 Long.class.getName(), Long.class.getName(),
3867 String.class.getName(), String.class.getName(),
3868
3869 Integer.class.getName(), Integer.class.getName(),
3870 OrderByComparator.class.getName()
3871 });
3872 public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_G_F_T_V =
3873 new FinderPath(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
3874 DLFileVersionModelImpl.FINDER_CACHE_ENABLED,
3875 DLFileVersionImpl.class, FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION,
3876 "findByG_F_T_V",
3877 new String[] {
3878 Long.class.getName(), Long.class.getName(),
3879 String.class.getName(), String.class.getName()
3880 },
3881 DLFileVersionModelImpl.GROUPID_COLUMN_BITMASK |
3882 DLFileVersionModelImpl.FOLDERID_COLUMN_BITMASK |
3883 DLFileVersionModelImpl.TITLE_COLUMN_BITMASK |
3884 DLFileVersionModelImpl.VERSION_COLUMN_BITMASK |
3885 DLFileVersionModelImpl.FILEENTRYID_COLUMN_BITMASK |
3886 DLFileVersionModelImpl.CREATEDATE_COLUMN_BITMASK);
3887 public static final FinderPath FINDER_PATH_COUNT_BY_G_F_T_V = new FinderPath(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
3888 DLFileVersionModelImpl.FINDER_CACHE_ENABLED, Long.class,
3889 FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByG_F_T_V",
3890 new String[] {
3891 Long.class.getName(), Long.class.getName(),
3892 String.class.getName(), String.class.getName()
3893 });
3894
3895
3905 @Override
3906 public List<DLFileVersion> findByG_F_T_V(long groupId, long folderId,
3907 String title, String version) throws SystemException {
3908 return findByG_F_T_V(groupId, folderId, title, version,
3909 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
3910 }
3911
3912
3928 @Override
3929 public List<DLFileVersion> findByG_F_T_V(long groupId, long folderId,
3930 String title, String version, int start, int end)
3931 throws SystemException {
3932 return findByG_F_T_V(groupId, folderId, title, version, start, end, null);
3933 }
3934
3935
3952 @Override
3953 public List<DLFileVersion> findByG_F_T_V(long groupId, long folderId,
3954 String title, String version, int start, int end,
3955 OrderByComparator orderByComparator) throws SystemException {
3956 boolean pagination = true;
3957 FinderPath finderPath = null;
3958 Object[] finderArgs = null;
3959
3960 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
3961 (orderByComparator == null)) {
3962 pagination = false;
3963 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_G_F_T_V;
3964 finderArgs = new Object[] { groupId, folderId, title, version };
3965 }
3966 else {
3967 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_G_F_T_V;
3968 finderArgs = new Object[] {
3969 groupId, folderId, title, version,
3970
3971 start, end, orderByComparator
3972 };
3973 }
3974
3975 List<DLFileVersion> list = (List<DLFileVersion>)FinderCacheUtil.getResult(finderPath,
3976 finderArgs, this);
3977
3978 if ((list != null) && !list.isEmpty()) {
3979 for (DLFileVersion dlFileVersion : list) {
3980 if ((groupId != dlFileVersion.getGroupId()) ||
3981 (folderId != dlFileVersion.getFolderId()) ||
3982 !Validator.equals(title, dlFileVersion.getTitle()) ||
3983 !Validator.equals(version, dlFileVersion.getVersion())) {
3984 list = null;
3985
3986 break;
3987 }
3988 }
3989 }
3990
3991 if (list == null) {
3992 StringBundler query = null;
3993
3994 if (orderByComparator != null) {
3995 query = new StringBundler(6 +
3996 (orderByComparator.getOrderByFields().length * 3));
3997 }
3998 else {
3999 query = new StringBundler(6);
4000 }
4001
4002 query.append(_SQL_SELECT_DLFILEVERSION_WHERE);
4003
4004 query.append(_FINDER_COLUMN_G_F_T_V_GROUPID_2);
4005
4006 query.append(_FINDER_COLUMN_G_F_T_V_FOLDERID_2);
4007
4008 boolean bindTitle = false;
4009
4010 if (title == null) {
4011 query.append(_FINDER_COLUMN_G_F_T_V_TITLE_1);
4012 }
4013 else if (title.equals(StringPool.BLANK)) {
4014 query.append(_FINDER_COLUMN_G_F_T_V_TITLE_3);
4015 }
4016 else {
4017 bindTitle = true;
4018
4019 query.append(_FINDER_COLUMN_G_F_T_V_TITLE_2);
4020 }
4021
4022 boolean bindVersion = false;
4023
4024 if (version == null) {
4025 query.append(_FINDER_COLUMN_G_F_T_V_VERSION_1);
4026 }
4027 else if (version.equals(StringPool.BLANK)) {
4028 query.append(_FINDER_COLUMN_G_F_T_V_VERSION_3);
4029 }
4030 else {
4031 bindVersion = true;
4032
4033 query.append(_FINDER_COLUMN_G_F_T_V_VERSION_2);
4034 }
4035
4036 if (orderByComparator != null) {
4037 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
4038 orderByComparator);
4039 }
4040 else
4041 if (pagination) {
4042 query.append(DLFileVersionModelImpl.ORDER_BY_JPQL);
4043 }
4044
4045 String sql = query.toString();
4046
4047 Session session = null;
4048
4049 try {
4050 session = openSession();
4051
4052 Query q = session.createQuery(sql);
4053
4054 QueryPos qPos = QueryPos.getInstance(q);
4055
4056 qPos.add(groupId);
4057
4058 qPos.add(folderId);
4059
4060 if (bindTitle) {
4061 qPos.add(title);
4062 }
4063
4064 if (bindVersion) {
4065 qPos.add(version);
4066 }
4067
4068 if (!pagination) {
4069 list = (List<DLFileVersion>)QueryUtil.list(q, getDialect(),
4070 start, end, false);
4071
4072 Collections.sort(list);
4073
4074 list = new UnmodifiableList<DLFileVersion>(list);
4075 }
4076 else {
4077 list = (List<DLFileVersion>)QueryUtil.list(q, getDialect(),
4078 start, end);
4079 }
4080
4081 cacheResult(list);
4082
4083 FinderCacheUtil.putResult(finderPath, finderArgs, list);
4084 }
4085 catch (Exception e) {
4086 FinderCacheUtil.removeResult(finderPath, finderArgs);
4087
4088 throw processException(e);
4089 }
4090 finally {
4091 closeSession(session);
4092 }
4093 }
4094
4095 return list;
4096 }
4097
4098
4110 @Override
4111 public DLFileVersion findByG_F_T_V_First(long groupId, long folderId,
4112 String title, String version, OrderByComparator orderByComparator)
4113 throws NoSuchFileVersionException, SystemException {
4114 DLFileVersion dlFileVersion = fetchByG_F_T_V_First(groupId, folderId,
4115 title, version, orderByComparator);
4116
4117 if (dlFileVersion != null) {
4118 return dlFileVersion;
4119 }
4120
4121 StringBundler msg = new StringBundler(10);
4122
4123 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
4124
4125 msg.append("groupId=");
4126 msg.append(groupId);
4127
4128 msg.append(", folderId=");
4129 msg.append(folderId);
4130
4131 msg.append(", title=");
4132 msg.append(title);
4133
4134 msg.append(", version=");
4135 msg.append(version);
4136
4137 msg.append(StringPool.CLOSE_CURLY_BRACE);
4138
4139 throw new NoSuchFileVersionException(msg.toString());
4140 }
4141
4142
4153 @Override
4154 public DLFileVersion fetchByG_F_T_V_First(long groupId, long folderId,
4155 String title, String version, OrderByComparator orderByComparator)
4156 throws SystemException {
4157 List<DLFileVersion> list = findByG_F_T_V(groupId, folderId, title,
4158 version, 0, 1, orderByComparator);
4159
4160 if (!list.isEmpty()) {
4161 return list.get(0);
4162 }
4163
4164 return null;
4165 }
4166
4167
4179 @Override
4180 public DLFileVersion findByG_F_T_V_Last(long groupId, long folderId,
4181 String title, String version, OrderByComparator orderByComparator)
4182 throws NoSuchFileVersionException, SystemException {
4183 DLFileVersion dlFileVersion = fetchByG_F_T_V_Last(groupId, folderId,
4184 title, version, orderByComparator);
4185
4186 if (dlFileVersion != null) {
4187 return dlFileVersion;
4188 }
4189
4190 StringBundler msg = new StringBundler(10);
4191
4192 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
4193
4194 msg.append("groupId=");
4195 msg.append(groupId);
4196
4197 msg.append(", folderId=");
4198 msg.append(folderId);
4199
4200 msg.append(", title=");
4201 msg.append(title);
4202
4203 msg.append(", version=");
4204 msg.append(version);
4205
4206 msg.append(StringPool.CLOSE_CURLY_BRACE);
4207
4208 throw new NoSuchFileVersionException(msg.toString());
4209 }
4210
4211
4222 @Override
4223 public DLFileVersion fetchByG_F_T_V_Last(long groupId, long folderId,
4224 String title, String version, OrderByComparator orderByComparator)
4225 throws SystemException {
4226 int count = countByG_F_T_V(groupId, folderId, title, version);
4227
4228 if (count == 0) {
4229 return null;
4230 }
4231
4232 List<DLFileVersion> list = findByG_F_T_V(groupId, folderId, title,
4233 version, count - 1, count, orderByComparator);
4234
4235 if (!list.isEmpty()) {
4236 return list.get(0);
4237 }
4238
4239 return null;
4240 }
4241
4242
4255 @Override
4256 public DLFileVersion[] findByG_F_T_V_PrevAndNext(long fileVersionId,
4257 long groupId, long folderId, String title, String version,
4258 OrderByComparator orderByComparator)
4259 throws NoSuchFileVersionException, SystemException {
4260 DLFileVersion dlFileVersion = findByPrimaryKey(fileVersionId);
4261
4262 Session session = null;
4263
4264 try {
4265 session = openSession();
4266
4267 DLFileVersion[] array = new DLFileVersionImpl[3];
4268
4269 array[0] = getByG_F_T_V_PrevAndNext(session, dlFileVersion,
4270 groupId, folderId, title, version, orderByComparator, true);
4271
4272 array[1] = dlFileVersion;
4273
4274 array[2] = getByG_F_T_V_PrevAndNext(session, dlFileVersion,
4275 groupId, folderId, title, version, orderByComparator, false);
4276
4277 return array;
4278 }
4279 catch (Exception e) {
4280 throw processException(e);
4281 }
4282 finally {
4283 closeSession(session);
4284 }
4285 }
4286
4287 protected DLFileVersion getByG_F_T_V_PrevAndNext(Session session,
4288 DLFileVersion dlFileVersion, long groupId, long folderId, String title,
4289 String version, OrderByComparator orderByComparator, boolean previous) {
4290 StringBundler query = null;
4291
4292 if (orderByComparator != null) {
4293 query = new StringBundler(6 +
4294 (orderByComparator.getOrderByFields().length * 6));
4295 }
4296 else {
4297 query = new StringBundler(3);
4298 }
4299
4300 query.append(_SQL_SELECT_DLFILEVERSION_WHERE);
4301
4302 query.append(_FINDER_COLUMN_G_F_T_V_GROUPID_2);
4303
4304 query.append(_FINDER_COLUMN_G_F_T_V_FOLDERID_2);
4305
4306 boolean bindTitle = false;
4307
4308 if (title == null) {
4309 query.append(_FINDER_COLUMN_G_F_T_V_TITLE_1);
4310 }
4311 else if (title.equals(StringPool.BLANK)) {
4312 query.append(_FINDER_COLUMN_G_F_T_V_TITLE_3);
4313 }
4314 else {
4315 bindTitle = true;
4316
4317 query.append(_FINDER_COLUMN_G_F_T_V_TITLE_2);
4318 }
4319
4320 boolean bindVersion = false;
4321
4322 if (version == null) {
4323 query.append(_FINDER_COLUMN_G_F_T_V_VERSION_1);
4324 }
4325 else if (version.equals(StringPool.BLANK)) {
4326 query.append(_FINDER_COLUMN_G_F_T_V_VERSION_3);
4327 }
4328 else {
4329 bindVersion = true;
4330
4331 query.append(_FINDER_COLUMN_G_F_T_V_VERSION_2);
4332 }
4333
4334 if (orderByComparator != null) {
4335 String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
4336
4337 if (orderByConditionFields.length > 0) {
4338 query.append(WHERE_AND);
4339 }
4340
4341 for (int i = 0; i < orderByConditionFields.length; i++) {
4342 query.append(_ORDER_BY_ENTITY_ALIAS);
4343 query.append(orderByConditionFields[i]);
4344
4345 if ((i + 1) < orderByConditionFields.length) {
4346 if (orderByComparator.isAscending() ^ previous) {
4347 query.append(WHERE_GREATER_THAN_HAS_NEXT);
4348 }
4349 else {
4350 query.append(WHERE_LESSER_THAN_HAS_NEXT);
4351 }
4352 }
4353 else {
4354 if (orderByComparator.isAscending() ^ previous) {
4355 query.append(WHERE_GREATER_THAN);
4356 }
4357 else {
4358 query.append(WHERE_LESSER_THAN);
4359 }
4360 }
4361 }
4362
4363 query.append(ORDER_BY_CLAUSE);
4364
4365 String[] orderByFields = orderByComparator.getOrderByFields();
4366
4367 for (int i = 0; i < orderByFields.length; i++) {
4368 query.append(_ORDER_BY_ENTITY_ALIAS);
4369 query.append(orderByFields[i]);
4370
4371 if ((i + 1) < orderByFields.length) {
4372 if (orderByComparator.isAscending() ^ previous) {
4373 query.append(ORDER_BY_ASC_HAS_NEXT);
4374 }
4375 else {
4376 query.append(ORDER_BY_DESC_HAS_NEXT);
4377 }
4378 }
4379 else {
4380 if (orderByComparator.isAscending() ^ previous) {
4381 query.append(ORDER_BY_ASC);
4382 }
4383 else {
4384 query.append(ORDER_BY_DESC);
4385 }
4386 }
4387 }
4388 }
4389 else {
4390 query.append(DLFileVersionModelImpl.ORDER_BY_JPQL);
4391 }
4392
4393 String sql = query.toString();
4394
4395 Query q = session.createQuery(sql);
4396
4397 q.setFirstResult(0);
4398 q.setMaxResults(2);
4399
4400 QueryPos qPos = QueryPos.getInstance(q);
4401
4402 qPos.add(groupId);
4403
4404 qPos.add(folderId);
4405
4406 if (bindTitle) {
4407 qPos.add(title);
4408 }
4409
4410 if (bindVersion) {
4411 qPos.add(version);
4412 }
4413
4414 if (orderByComparator != null) {
4415 Object[] values = orderByComparator.getOrderByConditionValues(dlFileVersion);
4416
4417 for (Object value : values) {
4418 qPos.add(value);
4419 }
4420 }
4421
4422 List<DLFileVersion> list = q.list();
4423
4424 if (list.size() == 2) {
4425 return list.get(1);
4426 }
4427 else {
4428 return null;
4429 }
4430 }
4431
4432
4441 @Override
4442 public void removeByG_F_T_V(long groupId, long folderId, String title,
4443 String version) throws SystemException {
4444 for (DLFileVersion dlFileVersion : findByG_F_T_V(groupId, folderId,
4445 title, version, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null)) {
4446 remove(dlFileVersion);
4447 }
4448 }
4449
4450
4460 @Override
4461 public int countByG_F_T_V(long groupId, long folderId, String title,
4462 String version) throws SystemException {
4463 FinderPath finderPath = FINDER_PATH_COUNT_BY_G_F_T_V;
4464
4465 Object[] finderArgs = new Object[] { groupId, folderId, title, version };
4466
4467 Long count = (Long)FinderCacheUtil.getResult(finderPath, finderArgs,
4468 this);
4469
4470 if (count == null) {
4471 StringBundler query = new StringBundler(5);
4472
4473 query.append(_SQL_COUNT_DLFILEVERSION_WHERE);
4474
4475 query.append(_FINDER_COLUMN_G_F_T_V_GROUPID_2);
4476
4477 query.append(_FINDER_COLUMN_G_F_T_V_FOLDERID_2);
4478
4479 boolean bindTitle = false;
4480
4481 if (title == null) {
4482 query.append(_FINDER_COLUMN_G_F_T_V_TITLE_1);
4483 }
4484 else if (title.equals(StringPool.BLANK)) {
4485 query.append(_FINDER_COLUMN_G_F_T_V_TITLE_3);
4486 }
4487 else {
4488 bindTitle = true;
4489
4490 query.append(_FINDER_COLUMN_G_F_T_V_TITLE_2);
4491 }
4492
4493 boolean bindVersion = false;
4494
4495 if (version == null) {
4496 query.append(_FINDER_COLUMN_G_F_T_V_VERSION_1);
4497 }
4498 else if (version.equals(StringPool.BLANK)) {
4499 query.append(_FINDER_COLUMN_G_F_T_V_VERSION_3);
4500 }
4501 else {
4502 bindVersion = true;
4503
4504 query.append(_FINDER_COLUMN_G_F_T_V_VERSION_2);
4505 }
4506
4507 String sql = query.toString();
4508
4509 Session session = null;
4510
4511 try {
4512 session = openSession();
4513
4514 Query q = session.createQuery(sql);
4515
4516 QueryPos qPos = QueryPos.getInstance(q);
4517
4518 qPos.add(groupId);
4519
4520 qPos.add(folderId);
4521
4522 if (bindTitle) {
4523 qPos.add(title);
4524 }
4525
4526 if (bindVersion) {
4527 qPos.add(version);
4528 }
4529
4530 count = (Long)q.uniqueResult();
4531
4532 FinderCacheUtil.putResult(finderPath, finderArgs, count);
4533 }
4534 catch (Exception e) {
4535 FinderCacheUtil.removeResult(finderPath, finderArgs);
4536
4537 throw processException(e);
4538 }
4539 finally {
4540 closeSession(session);
4541 }
4542 }
4543
4544 return count.intValue();
4545 }
4546
4547 private static final String _FINDER_COLUMN_G_F_T_V_GROUPID_2 = "dlFileVersion.groupId = ? AND ";
4548 private static final String _FINDER_COLUMN_G_F_T_V_FOLDERID_2 = "dlFileVersion.folderId = ? AND ";
4549 private static final String _FINDER_COLUMN_G_F_T_V_TITLE_1 = "dlFileVersion.title IS NULL AND ";
4550 private static final String _FINDER_COLUMN_G_F_T_V_TITLE_2 = "dlFileVersion.title = ? AND ";
4551 private static final String _FINDER_COLUMN_G_F_T_V_TITLE_3 = "(dlFileVersion.title IS NULL OR dlFileVersion.title = '') AND ";
4552 private static final String _FINDER_COLUMN_G_F_T_V_VERSION_1 = "dlFileVersion.version IS NULL";
4553 private static final String _FINDER_COLUMN_G_F_T_V_VERSION_2 = "dlFileVersion.version = ?";
4554 private static final String _FINDER_COLUMN_G_F_T_V_VERSION_3 = "(dlFileVersion.version IS NULL OR dlFileVersion.version = '')";
4555
4556 public DLFileVersionPersistenceImpl() {
4557 setModelClass(DLFileVersion.class);
4558 }
4559
4560
4565 @Override
4566 public void cacheResult(DLFileVersion dlFileVersion) {
4567 EntityCacheUtil.putResult(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
4568 DLFileVersionImpl.class, dlFileVersion.getPrimaryKey(),
4569 dlFileVersion);
4570
4571 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
4572 new Object[] { dlFileVersion.getUuid(), dlFileVersion.getGroupId() },
4573 dlFileVersion);
4574
4575 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_F_V,
4576 new Object[] {
4577 dlFileVersion.getFileEntryId(), dlFileVersion.getVersion()
4578 }, dlFileVersion);
4579
4580 dlFileVersion.resetOriginalValues();
4581 }
4582
4583
4588 @Override
4589 public void cacheResult(List<DLFileVersion> dlFileVersions) {
4590 for (DLFileVersion dlFileVersion : dlFileVersions) {
4591 if (EntityCacheUtil.getResult(
4592 DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
4593 DLFileVersionImpl.class, dlFileVersion.getPrimaryKey()) == null) {
4594 cacheResult(dlFileVersion);
4595 }
4596 else {
4597 dlFileVersion.resetOriginalValues();
4598 }
4599 }
4600 }
4601
4602
4609 @Override
4610 public void clearCache() {
4611 if (_HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE) {
4612 CacheRegistryUtil.clear(DLFileVersionImpl.class.getName());
4613 }
4614
4615 EntityCacheUtil.clearCache(DLFileVersionImpl.class.getName());
4616
4617 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
4618 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
4619 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
4620 }
4621
4622
4629 @Override
4630 public void clearCache(DLFileVersion dlFileVersion) {
4631 EntityCacheUtil.removeResult(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
4632 DLFileVersionImpl.class, dlFileVersion.getPrimaryKey());
4633
4634 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
4635 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
4636
4637 clearUniqueFindersCache(dlFileVersion);
4638 }
4639
4640 @Override
4641 public void clearCache(List<DLFileVersion> dlFileVersions) {
4642 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
4643 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
4644
4645 for (DLFileVersion dlFileVersion : dlFileVersions) {
4646 EntityCacheUtil.removeResult(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
4647 DLFileVersionImpl.class, dlFileVersion.getPrimaryKey());
4648
4649 clearUniqueFindersCache(dlFileVersion);
4650 }
4651 }
4652
4653 protected void cacheUniqueFindersCache(DLFileVersion dlFileVersion) {
4654 if (dlFileVersion.isNew()) {
4655 Object[] args = new Object[] {
4656 dlFileVersion.getUuid(), dlFileVersion.getGroupId()
4657 };
4658
4659 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID_G, args,
4660 Long.valueOf(1));
4661 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G, args,
4662 dlFileVersion);
4663
4664 args = new Object[] {
4665 dlFileVersion.getFileEntryId(), dlFileVersion.getVersion()
4666 };
4667
4668 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_F_V, args,
4669 Long.valueOf(1));
4670 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_F_V, args,
4671 dlFileVersion);
4672 }
4673 else {
4674 DLFileVersionModelImpl dlFileVersionModelImpl = (DLFileVersionModelImpl)dlFileVersion;
4675
4676 if ((dlFileVersionModelImpl.getColumnBitmask() &
4677 FINDER_PATH_FETCH_BY_UUID_G.getColumnBitmask()) != 0) {
4678 Object[] args = new Object[] {
4679 dlFileVersion.getUuid(), dlFileVersion.getGroupId()
4680 };
4681
4682 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID_G, args,
4683 Long.valueOf(1));
4684 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G, args,
4685 dlFileVersion);
4686 }
4687
4688 if ((dlFileVersionModelImpl.getColumnBitmask() &
4689 FINDER_PATH_FETCH_BY_F_V.getColumnBitmask()) != 0) {
4690 Object[] args = new Object[] {
4691 dlFileVersion.getFileEntryId(),
4692 dlFileVersion.getVersion()
4693 };
4694
4695 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_F_V, args,
4696 Long.valueOf(1));
4697 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_F_V, args,
4698 dlFileVersion);
4699 }
4700 }
4701 }
4702
4703 protected void clearUniqueFindersCache(DLFileVersion dlFileVersion) {
4704 DLFileVersionModelImpl dlFileVersionModelImpl = (DLFileVersionModelImpl)dlFileVersion;
4705
4706 Object[] args = new Object[] {
4707 dlFileVersion.getUuid(), dlFileVersion.getGroupId()
4708 };
4709
4710 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID_G, args);
4711 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G, args);
4712
4713 if ((dlFileVersionModelImpl.getColumnBitmask() &
4714 FINDER_PATH_FETCH_BY_UUID_G.getColumnBitmask()) != 0) {
4715 args = new Object[] {
4716 dlFileVersionModelImpl.getOriginalUuid(),
4717 dlFileVersionModelImpl.getOriginalGroupId()
4718 };
4719
4720 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID_G, args);
4721 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G, args);
4722 }
4723
4724 args = new Object[] {
4725 dlFileVersion.getFileEntryId(), dlFileVersion.getVersion()
4726 };
4727
4728 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_F_V, args);
4729 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_F_V, args);
4730
4731 if ((dlFileVersionModelImpl.getColumnBitmask() &
4732 FINDER_PATH_FETCH_BY_F_V.getColumnBitmask()) != 0) {
4733 args = new Object[] {
4734 dlFileVersionModelImpl.getOriginalFileEntryId(),
4735 dlFileVersionModelImpl.getOriginalVersion()
4736 };
4737
4738 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_F_V, args);
4739 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_F_V, args);
4740 }
4741 }
4742
4743
4749 @Override
4750 public DLFileVersion create(long fileVersionId) {
4751 DLFileVersion dlFileVersion = new DLFileVersionImpl();
4752
4753 dlFileVersion.setNew(true);
4754 dlFileVersion.setPrimaryKey(fileVersionId);
4755
4756 String uuid = PortalUUIDUtil.generate();
4757
4758 dlFileVersion.setUuid(uuid);
4759
4760 return dlFileVersion;
4761 }
4762
4763
4771 @Override
4772 public DLFileVersion remove(long fileVersionId)
4773 throws NoSuchFileVersionException, SystemException {
4774 return remove((Serializable)fileVersionId);
4775 }
4776
4777
4785 @Override
4786 public DLFileVersion remove(Serializable primaryKey)
4787 throws NoSuchFileVersionException, SystemException {
4788 Session session = null;
4789
4790 try {
4791 session = openSession();
4792
4793 DLFileVersion dlFileVersion = (DLFileVersion)session.get(DLFileVersionImpl.class,
4794 primaryKey);
4795
4796 if (dlFileVersion == null) {
4797 if (_log.isWarnEnabled()) {
4798 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey);
4799 }
4800
4801 throw new NoSuchFileVersionException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
4802 primaryKey);
4803 }
4804
4805 return remove(dlFileVersion);
4806 }
4807 catch (NoSuchFileVersionException nsee) {
4808 throw nsee;
4809 }
4810 catch (Exception e) {
4811 throw processException(e);
4812 }
4813 finally {
4814 closeSession(session);
4815 }
4816 }
4817
4818 @Override
4819 protected DLFileVersion removeImpl(DLFileVersion dlFileVersion)
4820 throws SystemException {
4821 dlFileVersion = toUnwrappedModel(dlFileVersion);
4822
4823 Session session = null;
4824
4825 try {
4826 session = openSession();
4827
4828 if (!session.contains(dlFileVersion)) {
4829 dlFileVersion = (DLFileVersion)session.get(DLFileVersionImpl.class,
4830 dlFileVersion.getPrimaryKeyObj());
4831 }
4832
4833 if (dlFileVersion != null) {
4834 session.delete(dlFileVersion);
4835 }
4836 }
4837 catch (Exception e) {
4838 throw processException(e);
4839 }
4840 finally {
4841 closeSession(session);
4842 }
4843
4844 if (dlFileVersion != null) {
4845 clearCache(dlFileVersion);
4846 }
4847
4848 return dlFileVersion;
4849 }
4850
4851 @Override
4852 public DLFileVersion updateImpl(
4853 com.liferay.portlet.documentlibrary.model.DLFileVersion dlFileVersion)
4854 throws SystemException {
4855 dlFileVersion = toUnwrappedModel(dlFileVersion);
4856
4857 boolean isNew = dlFileVersion.isNew();
4858
4859 DLFileVersionModelImpl dlFileVersionModelImpl = (DLFileVersionModelImpl)dlFileVersion;
4860
4861 if (Validator.isNull(dlFileVersion.getUuid())) {
4862 String uuid = PortalUUIDUtil.generate();
4863
4864 dlFileVersion.setUuid(uuid);
4865 }
4866
4867 Session session = null;
4868
4869 try {
4870 session = openSession();
4871
4872 if (dlFileVersion.isNew()) {
4873 session.save(dlFileVersion);
4874
4875 dlFileVersion.setNew(false);
4876 }
4877 else {
4878 session.merge(dlFileVersion);
4879 }
4880 }
4881 catch (Exception e) {
4882 throw processException(e);
4883 }
4884 finally {
4885 closeSession(session);
4886 }
4887
4888 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
4889
4890 if (isNew || !DLFileVersionModelImpl.COLUMN_BITMASK_ENABLED) {
4891 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
4892 }
4893
4894 else {
4895 if ((dlFileVersionModelImpl.getColumnBitmask() &
4896 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID.getColumnBitmask()) != 0) {
4897 Object[] args = new Object[] {
4898 dlFileVersionModelImpl.getOriginalUuid()
4899 };
4900
4901 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID, args);
4902 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID,
4903 args);
4904
4905 args = new Object[] { dlFileVersionModelImpl.getUuid() };
4906
4907 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID, args);
4908 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID,
4909 args);
4910 }
4911
4912 if ((dlFileVersionModelImpl.getColumnBitmask() &
4913 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C.getColumnBitmask()) != 0) {
4914 Object[] args = new Object[] {
4915 dlFileVersionModelImpl.getOriginalUuid(),
4916 dlFileVersionModelImpl.getOriginalCompanyId()
4917 };
4918
4919 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID_C, args);
4920 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C,
4921 args);
4922
4923 args = new Object[] {
4924 dlFileVersionModelImpl.getUuid(),
4925 dlFileVersionModelImpl.getCompanyId()
4926 };
4927
4928 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID_C, args);
4929 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID_C,
4930 args);
4931 }
4932
4933 if ((dlFileVersionModelImpl.getColumnBitmask() &
4934 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_FILEENTRYID.getColumnBitmask()) != 0) {
4935 Object[] args = new Object[] {
4936 dlFileVersionModelImpl.getOriginalFileEntryId()
4937 };
4938
4939 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_FILEENTRYID,
4940 args);
4941 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_FILEENTRYID,
4942 args);
4943
4944 args = new Object[] { dlFileVersionModelImpl.getFileEntryId() };
4945
4946 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_FILEENTRYID,
4947 args);
4948 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_FILEENTRYID,
4949 args);
4950 }
4951
4952 if ((dlFileVersionModelImpl.getColumnBitmask() &
4953 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_MIMETYPE.getColumnBitmask()) != 0) {
4954 Object[] args = new Object[] {
4955 dlFileVersionModelImpl.getOriginalMimeType()
4956 };
4957
4958 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_MIMETYPE, args);
4959 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_MIMETYPE,
4960 args);
4961
4962 args = new Object[] { dlFileVersionModelImpl.getMimeType() };
4963
4964 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_MIMETYPE, args);
4965 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_MIMETYPE,
4966 args);
4967 }
4968
4969 if ((dlFileVersionModelImpl.getColumnBitmask() &
4970 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_F_S.getColumnBitmask()) != 0) {
4971 Object[] args = new Object[] {
4972 dlFileVersionModelImpl.getOriginalFileEntryId(),
4973 dlFileVersionModelImpl.getOriginalStatus()
4974 };
4975
4976 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_F_S, args);
4977 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_F_S,
4978 args);
4979
4980 args = new Object[] {
4981 dlFileVersionModelImpl.getFileEntryId(),
4982 dlFileVersionModelImpl.getStatus()
4983 };
4984
4985 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_F_S, args);
4986 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_F_S,
4987 args);
4988 }
4989
4990 if ((dlFileVersionModelImpl.getColumnBitmask() &
4991 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_G_F_S.getColumnBitmask()) != 0) {
4992 Object[] args = new Object[] {
4993 dlFileVersionModelImpl.getOriginalGroupId(),
4994 dlFileVersionModelImpl.getOriginalFolderId(),
4995 dlFileVersionModelImpl.getOriginalStatus()
4996 };
4997
4998 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_G_F_S, args);
4999 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_G_F_S,
5000 args);
5001
5002 args = new Object[] {
5003 dlFileVersionModelImpl.getGroupId(),
5004 dlFileVersionModelImpl.getFolderId(),
5005 dlFileVersionModelImpl.getStatus()
5006 };
5007
5008 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_G_F_S, args);
5009 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_G_F_S,
5010 args);
5011 }
5012
5013 if ((dlFileVersionModelImpl.getColumnBitmask() &
5014 FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_G_F_T_V.getColumnBitmask()) != 0) {
5015 Object[] args = new Object[] {
5016 dlFileVersionModelImpl.getOriginalGroupId(),
5017 dlFileVersionModelImpl.getOriginalFolderId(),
5018 dlFileVersionModelImpl.getOriginalTitle(),
5019 dlFileVersionModelImpl.getOriginalVersion()
5020 };
5021
5022 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_G_F_T_V, args);
5023 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_G_F_T_V,
5024 args);
5025
5026 args = new Object[] {
5027 dlFileVersionModelImpl.getGroupId(),
5028 dlFileVersionModelImpl.getFolderId(),
5029 dlFileVersionModelImpl.getTitle(),
5030 dlFileVersionModelImpl.getVersion()
5031 };
5032
5033 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_G_F_T_V, args);
5034 FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_G_F_T_V,
5035 args);
5036 }
5037 }
5038
5039 EntityCacheUtil.putResult(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
5040 DLFileVersionImpl.class, dlFileVersion.getPrimaryKey(),
5041 dlFileVersion);
5042
5043 clearUniqueFindersCache(dlFileVersion);
5044 cacheUniqueFindersCache(dlFileVersion);
5045
5046 return dlFileVersion;
5047 }
5048
5049 protected DLFileVersion toUnwrappedModel(DLFileVersion dlFileVersion) {
5050 if (dlFileVersion instanceof DLFileVersionImpl) {
5051 return dlFileVersion;
5052 }
5053
5054 DLFileVersionImpl dlFileVersionImpl = new DLFileVersionImpl();
5055
5056 dlFileVersionImpl.setNew(dlFileVersion.isNew());
5057 dlFileVersionImpl.setPrimaryKey(dlFileVersion.getPrimaryKey());
5058
5059 dlFileVersionImpl.setUuid(dlFileVersion.getUuid());
5060 dlFileVersionImpl.setFileVersionId(dlFileVersion.getFileVersionId());
5061 dlFileVersionImpl.setGroupId(dlFileVersion.getGroupId());
5062 dlFileVersionImpl.setCompanyId(dlFileVersion.getCompanyId());
5063 dlFileVersionImpl.setUserId(dlFileVersion.getUserId());
5064 dlFileVersionImpl.setUserName(dlFileVersion.getUserName());
5065 dlFileVersionImpl.setCreateDate(dlFileVersion.getCreateDate());
5066 dlFileVersionImpl.setModifiedDate(dlFileVersion.getModifiedDate());
5067 dlFileVersionImpl.setRepositoryId(dlFileVersion.getRepositoryId());
5068 dlFileVersionImpl.setFolderId(dlFileVersion.getFolderId());
5069 dlFileVersionImpl.setFileEntryId(dlFileVersion.getFileEntryId());
5070 dlFileVersionImpl.setExtension(dlFileVersion.getExtension());
5071 dlFileVersionImpl.setMimeType(dlFileVersion.getMimeType());
5072 dlFileVersionImpl.setTitle(dlFileVersion.getTitle());
5073 dlFileVersionImpl.setDescription(dlFileVersion.getDescription());
5074 dlFileVersionImpl.setChangeLog(dlFileVersion.getChangeLog());
5075 dlFileVersionImpl.setExtraSettings(dlFileVersion.getExtraSettings());
5076 dlFileVersionImpl.setFileEntryTypeId(dlFileVersion.getFileEntryTypeId());
5077 dlFileVersionImpl.setVersion(dlFileVersion.getVersion());
5078 dlFileVersionImpl.setSize(dlFileVersion.getSize());
5079 dlFileVersionImpl.setChecksum(dlFileVersion.getChecksum());
5080 dlFileVersionImpl.setStatus(dlFileVersion.getStatus());
5081 dlFileVersionImpl.setStatusByUserId(dlFileVersion.getStatusByUserId());
5082 dlFileVersionImpl.setStatusByUserName(dlFileVersion.getStatusByUserName());
5083 dlFileVersionImpl.setStatusDate(dlFileVersion.getStatusDate());
5084
5085 return dlFileVersionImpl;
5086 }
5087
5088
5096 @Override
5097 public DLFileVersion findByPrimaryKey(Serializable primaryKey)
5098 throws NoSuchFileVersionException, SystemException {
5099 DLFileVersion dlFileVersion = fetchByPrimaryKey(primaryKey);
5100
5101 if (dlFileVersion == null) {
5102 if (_log.isWarnEnabled()) {
5103 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey);
5104 }
5105
5106 throw new NoSuchFileVersionException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
5107 primaryKey);
5108 }
5109
5110 return dlFileVersion;
5111 }
5112
5113
5121 @Override
5122 public DLFileVersion findByPrimaryKey(long fileVersionId)
5123 throws NoSuchFileVersionException, SystemException {
5124 return findByPrimaryKey((Serializable)fileVersionId);
5125 }
5126
5127
5134 @Override
5135 public DLFileVersion fetchByPrimaryKey(Serializable primaryKey)
5136 throws SystemException {
5137 DLFileVersion dlFileVersion = (DLFileVersion)EntityCacheUtil.getResult(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
5138 DLFileVersionImpl.class, primaryKey);
5139
5140 if (dlFileVersion == _nullDLFileVersion) {
5141 return null;
5142 }
5143
5144 if (dlFileVersion == null) {
5145 Session session = null;
5146
5147 try {
5148 session = openSession();
5149
5150 dlFileVersion = (DLFileVersion)session.get(DLFileVersionImpl.class,
5151 primaryKey);
5152
5153 if (dlFileVersion != null) {
5154 cacheResult(dlFileVersion);
5155 }
5156 else {
5157 EntityCacheUtil.putResult(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
5158 DLFileVersionImpl.class, primaryKey, _nullDLFileVersion);
5159 }
5160 }
5161 catch (Exception e) {
5162 EntityCacheUtil.removeResult(DLFileVersionModelImpl.ENTITY_CACHE_ENABLED,
5163 DLFileVersionImpl.class, primaryKey);
5164
5165 throw processException(e);
5166 }
5167 finally {
5168 closeSession(session);
5169 }
5170 }
5171
5172 return dlFileVersion;
5173 }
5174
5175
5182 @Override
5183 public DLFileVersion fetchByPrimaryKey(long fileVersionId)
5184 throws SystemException {
5185 return fetchByPrimaryKey((Serializable)fileVersionId);
5186 }
5187
5188
5194 @Override
5195 public List<DLFileVersion> findAll() throws SystemException {
5196 return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
5197 }
5198
5199
5211 @Override
5212 public List<DLFileVersion> findAll(int start, int end)
5213 throws SystemException {
5214 return findAll(start, end, null);
5215 }
5216
5217
5230 @Override
5231 public List<DLFileVersion> findAll(int start, int end,
5232 OrderByComparator orderByComparator) throws SystemException {
5233 boolean pagination = true;
5234 FinderPath finderPath = null;
5235 Object[] finderArgs = null;
5236
5237 if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
5238 (orderByComparator == null)) {
5239 pagination = false;
5240 finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL;
5241 finderArgs = FINDER_ARGS_EMPTY;
5242 }
5243 else {
5244 finderPath = FINDER_PATH_WITH_PAGINATION_FIND_ALL;
5245 finderArgs = new Object[] { start, end, orderByComparator };
5246 }
5247
5248 List<DLFileVersion> list = (List<DLFileVersion>)FinderCacheUtil.getResult(finderPath,
5249 finderArgs, this);
5250
5251 if (list == null) {
5252 StringBundler query = null;
5253 String sql = null;
5254
5255 if (orderByComparator != null) {
5256 query = new StringBundler(2 +
5257 (orderByComparator.getOrderByFields().length * 3));
5258
5259 query.append(_SQL_SELECT_DLFILEVERSION);
5260
5261 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
5262 orderByComparator);
5263
5264 sql = query.toString();
5265 }
5266 else {
5267 sql = _SQL_SELECT_DLFILEVERSION;
5268
5269 if (pagination) {
5270 sql = sql.concat(DLFileVersionModelImpl.ORDER_BY_JPQL);
5271 }
5272 }
5273
5274 Session session = null;
5275
5276 try {
5277 session = openSession();
5278
5279 Query q = session.createQuery(sql);
5280
5281 if (!pagination) {
5282 list = (List<DLFileVersion>)QueryUtil.list(q, getDialect(),
5283 start, end, false);
5284
5285 Collections.sort(list);
5286
5287 list = new UnmodifiableList<DLFileVersion>(list);
5288 }
5289 else {
5290 list = (List<DLFileVersion>)QueryUtil.list(q, getDialect(),
5291 start, end);
5292 }
5293
5294 cacheResult(list);
5295
5296 FinderCacheUtil.putResult(finderPath, finderArgs, list);
5297 }
5298 catch (Exception e) {
5299 FinderCacheUtil.removeResult(finderPath, finderArgs);
5300
5301 throw processException(e);
5302 }
5303 finally {
5304 closeSession(session);
5305 }
5306 }
5307
5308 return list;
5309 }
5310
5311
5316 @Override
5317 public void removeAll() throws SystemException {
5318 for (DLFileVersion dlFileVersion : findAll()) {
5319 remove(dlFileVersion);
5320 }
5321 }
5322
5323
5329 @Override
5330 public int countAll() throws SystemException {
5331 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
5332 FINDER_ARGS_EMPTY, this);
5333
5334 if (count == null) {
5335 Session session = null;
5336
5337 try {
5338 session = openSession();
5339
5340 Query q = session.createQuery(_SQL_COUNT_DLFILEVERSION);
5341
5342 count = (Long)q.uniqueResult();
5343
5344 FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL,
5345 FINDER_ARGS_EMPTY, count);
5346 }
5347 catch (Exception e) {
5348 FinderCacheUtil.removeResult(FINDER_PATH_COUNT_ALL,
5349 FINDER_ARGS_EMPTY);
5350
5351 throw processException(e);
5352 }
5353 finally {
5354 closeSession(session);
5355 }
5356 }
5357
5358 return count.intValue();
5359 }
5360
5361 @Override
5362 protected Set<String> getBadColumnNames() {
5363 return _badColumnNames;
5364 }
5365
5366
5369 public void afterPropertiesSet() {
5370 String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
5371 com.liferay.portal.util.PropsUtil.get(
5372 "value.object.listener.com.liferay.portlet.documentlibrary.model.DLFileVersion")));
5373
5374 if (listenerClassNames.length > 0) {
5375 try {
5376 List<ModelListener<DLFileVersion>> listenersList = new ArrayList<ModelListener<DLFileVersion>>();
5377
5378 for (String listenerClassName : listenerClassNames) {
5379 listenersList.add((ModelListener<DLFileVersion>)InstanceFactory.newInstance(
5380 getClassLoader(), listenerClassName));
5381 }
5382
5383 listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
5384 }
5385 catch (Exception e) {
5386 _log.error(e);
5387 }
5388 }
5389 }
5390
5391 public void destroy() {
5392 EntityCacheUtil.removeCache(DLFileVersionImpl.class.getName());
5393 FinderCacheUtil.removeCache(FINDER_CLASS_NAME_ENTITY);
5394 FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
5395 FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
5396 }
5397
5398 private static final String _SQL_SELECT_DLFILEVERSION = "SELECT dlFileVersion FROM DLFileVersion dlFileVersion";
5399 private static final String _SQL_SELECT_DLFILEVERSION_WHERE = "SELECT dlFileVersion FROM DLFileVersion dlFileVersion WHERE ";
5400 private static final String _SQL_COUNT_DLFILEVERSION = "SELECT COUNT(dlFileVersion) FROM DLFileVersion dlFileVersion";
5401 private static final String _SQL_COUNT_DLFILEVERSION_WHERE = "SELECT COUNT(dlFileVersion) FROM DLFileVersion dlFileVersion WHERE ";
5402 private static final String _ORDER_BY_ENTITY_ALIAS = "dlFileVersion.";
5403 private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No DLFileVersion exists with the primary key ";
5404 private static final String _NO_SUCH_ENTITY_WITH_KEY = "No DLFileVersion exists with the key {";
5405 private static final boolean _HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE = com.liferay.portal.util.PropsValues.HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE;
5406 private static Log _log = LogFactoryUtil.getLog(DLFileVersionPersistenceImpl.class);
5407 private static Set<String> _badColumnNames = SetUtil.fromArray(new String[] {
5408 "uuid", "size"
5409 });
5410 private static DLFileVersion _nullDLFileVersion = new DLFileVersionImpl() {
5411 @Override
5412 public Object clone() {
5413 return this;
5414 }
5415
5416 @Override
5417 public CacheModel<DLFileVersion> toCacheModel() {
5418 return _nullDLFileVersionCacheModel;
5419 }
5420 };
5421
5422 private static CacheModel<DLFileVersion> _nullDLFileVersionCacheModel = new CacheModel<DLFileVersion>() {
5423 @Override
5424 public DLFileVersion toEntityModel() {
5425 return _nullDLFileVersion;
5426 }
5427 };
5428 }