1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * This library is free software; you can redistribute it and/or modify it under
5    * the terms of the GNU Lesser General Public License as published by the Free
6    * Software Foundation; either version 2.1 of the License, or (at your option)
7    * any later version.
8    *
9    * This library is distributed in the hope that it will be useful, but WITHOUT
10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11   * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
12   * details.
13   */
14  
15  package com.liferay.portlet.documentlibrary.service.persistence;
16  
17  import com.liferay.portal.NoSuchModelException;
18  import com.liferay.portal.kernel.annotation.BeanReference;
19  import com.liferay.portal.kernel.cache.CacheRegistry;
20  import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
21  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
22  import com.liferay.portal.kernel.dao.orm.FinderPath;
23  import com.liferay.portal.kernel.dao.orm.Query;
24  import com.liferay.portal.kernel.dao.orm.QueryPos;
25  import com.liferay.portal.kernel.dao.orm.QueryUtil;
26  import com.liferay.portal.kernel.dao.orm.Session;
27  import com.liferay.portal.kernel.exception.SystemException;
28  import com.liferay.portal.kernel.log.Log;
29  import com.liferay.portal.kernel.log.LogFactoryUtil;
30  import com.liferay.portal.kernel.util.GetterUtil;
31  import com.liferay.portal.kernel.util.InstanceFactory;
32  import com.liferay.portal.kernel.util.OrderByComparator;
33  import com.liferay.portal.kernel.util.StringBundler;
34  import com.liferay.portal.kernel.util.StringPool;
35  import com.liferay.portal.kernel.util.StringUtil;
36  import com.liferay.portal.kernel.util.Validator;
37  import com.liferay.portal.model.ModelListener;
38  import com.liferay.portal.service.persistence.BatchSessionUtil;
39  import com.liferay.portal.service.persistence.LayoutPersistence;
40  import com.liferay.portal.service.persistence.ResourcePersistence;
41  import com.liferay.portal.service.persistence.UserPersistence;
42  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
43  
44  import com.liferay.portlet.documentlibrary.NoSuchFileRankException;
45  import com.liferay.portlet.documentlibrary.model.DLFileRank;
46  import com.liferay.portlet.documentlibrary.model.impl.DLFileRankImpl;
47  import com.liferay.portlet.documentlibrary.model.impl.DLFileRankModelImpl;
48  
49  import java.io.Serializable;
50  
51  import java.util.ArrayList;
52  import java.util.Collections;
53  import java.util.List;
54  
55  /**
56   * <a href="DLFileRankPersistenceImpl.java.html"><b><i>View Source</i></b></a>
57   *
58   * <p>
59   * ServiceBuilder generated this class. Modifications in this class will be
60   * overwritten the next time is generated.
61   * </p>
62   *
63   * @author    Brian Wing Shun Chan
64   * @see       DLFileRankPersistence
65   * @see       DLFileRankUtil
66   * @generated
67   */
68  public class DLFileRankPersistenceImpl extends BasePersistenceImpl<DLFileRank>
69      implements DLFileRankPersistence {
70      public static final String FINDER_CLASS_NAME_ENTITY = DLFileRankImpl.class.getName();
71      public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
72          ".List";
73      public static final FinderPath FINDER_PATH_FIND_BY_USERID = new FinderPath(DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
74              DLFileRankModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
75              "findByUserId",
76              new String[] {
77                  Long.class.getName(),
78                  
79              "java.lang.Integer", "java.lang.Integer",
80                  "com.liferay.portal.kernel.util.OrderByComparator"
81              });
82      public static final FinderPath FINDER_PATH_COUNT_BY_USERID = new FinderPath(DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
83              DLFileRankModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
84              "countByUserId", new String[] { Long.class.getName() });
85      public static final FinderPath FINDER_PATH_FIND_BY_G_U = new FinderPath(DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
86              DLFileRankModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
87              "findByG_U",
88              new String[] {
89                  Long.class.getName(), Long.class.getName(),
90                  
91              "java.lang.Integer", "java.lang.Integer",
92                  "com.liferay.portal.kernel.util.OrderByComparator"
93              });
94      public static final FinderPath FINDER_PATH_COUNT_BY_G_U = new FinderPath(DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
95              DLFileRankModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
96              "countByG_U",
97              new String[] { Long.class.getName(), Long.class.getName() });
98      public static final FinderPath FINDER_PATH_FIND_BY_F_N = new FinderPath(DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
99              DLFileRankModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
100             "findByF_N",
101             new String[] {
102                 Long.class.getName(), String.class.getName(),
103                 
104             "java.lang.Integer", "java.lang.Integer",
105                 "com.liferay.portal.kernel.util.OrderByComparator"
106             });
107     public static final FinderPath FINDER_PATH_COUNT_BY_F_N = new FinderPath(DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
108             DLFileRankModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
109             "countByF_N",
110             new String[] { Long.class.getName(), String.class.getName() });
111     public static final FinderPath FINDER_PATH_FETCH_BY_C_U_F_N = new FinderPath(DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
112             DLFileRankModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_ENTITY,
113             "fetchByC_U_F_N",
114             new String[] {
115                 Long.class.getName(), Long.class.getName(), Long.class.getName(),
116                 String.class.getName()
117             });
118     public static final FinderPath FINDER_PATH_COUNT_BY_C_U_F_N = new FinderPath(DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
119             DLFileRankModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
120             "countByC_U_F_N",
121             new String[] {
122                 Long.class.getName(), Long.class.getName(), Long.class.getName(),
123                 String.class.getName()
124             });
125     public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
126             DLFileRankModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
127             "findAll", new String[0]);
128     public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
129             DLFileRankModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
130             "countAll", new String[0]);
131 
132     public void cacheResult(DLFileRank dlFileRank) {
133         EntityCacheUtil.putResult(DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
134             DLFileRankImpl.class, dlFileRank.getPrimaryKey(), dlFileRank);
135 
136         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_U_F_N,
137             new Object[] {
138                 new Long(dlFileRank.getCompanyId()),
139                 new Long(dlFileRank.getUserId()),
140                 new Long(dlFileRank.getFolderId()),
141                 
142             dlFileRank.getName()
143             }, dlFileRank);
144     }
145 
146     public void cacheResult(List<DLFileRank> dlFileRanks) {
147         for (DLFileRank dlFileRank : dlFileRanks) {
148             if (EntityCacheUtil.getResult(
149                         DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
150                         DLFileRankImpl.class, dlFileRank.getPrimaryKey(), this) == null) {
151                 cacheResult(dlFileRank);
152             }
153         }
154     }
155 
156     public void clearCache() {
157         CacheRegistry.clear(DLFileRankImpl.class.getName());
158         EntityCacheUtil.clearCache(DLFileRankImpl.class.getName());
159         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
160         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
161     }
162 
163     public void clearCache(DLFileRank dlFileRank) {
164         EntityCacheUtil.removeResult(DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
165             DLFileRankImpl.class, dlFileRank.getPrimaryKey());
166 
167         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_U_F_N,
168             new Object[] {
169                 new Long(dlFileRank.getCompanyId()),
170                 new Long(dlFileRank.getUserId()),
171                 new Long(dlFileRank.getFolderId()),
172                 
173             dlFileRank.getName()
174             });
175     }
176 
177     public DLFileRank create(long fileRankId) {
178         DLFileRank dlFileRank = new DLFileRankImpl();
179 
180         dlFileRank.setNew(true);
181         dlFileRank.setPrimaryKey(fileRankId);
182 
183         return dlFileRank;
184     }
185 
186     public DLFileRank remove(Serializable primaryKey)
187         throws NoSuchModelException, SystemException {
188         return remove(((Long)primaryKey).longValue());
189     }
190 
191     public DLFileRank remove(long fileRankId)
192         throws NoSuchFileRankException, SystemException {
193         Session session = null;
194 
195         try {
196             session = openSession();
197 
198             DLFileRank dlFileRank = (DLFileRank)session.get(DLFileRankImpl.class,
199                     new Long(fileRankId));
200 
201             if (dlFileRank == null) {
202                 if (_log.isWarnEnabled()) {
203                     _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + fileRankId);
204                 }
205 
206                 throw new NoSuchFileRankException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
207                     fileRankId);
208             }
209 
210             return remove(dlFileRank);
211         }
212         catch (NoSuchFileRankException nsee) {
213             throw nsee;
214         }
215         catch (Exception e) {
216             throw processException(e);
217         }
218         finally {
219             closeSession(session);
220         }
221     }
222 
223     public DLFileRank remove(DLFileRank dlFileRank) throws SystemException {
224         for (ModelListener<DLFileRank> listener : listeners) {
225             listener.onBeforeRemove(dlFileRank);
226         }
227 
228         dlFileRank = removeImpl(dlFileRank);
229 
230         for (ModelListener<DLFileRank> listener : listeners) {
231             listener.onAfterRemove(dlFileRank);
232         }
233 
234         return dlFileRank;
235     }
236 
237     protected DLFileRank removeImpl(DLFileRank dlFileRank)
238         throws SystemException {
239         dlFileRank = toUnwrappedModel(dlFileRank);
240 
241         Session session = null;
242 
243         try {
244             session = openSession();
245 
246             if (dlFileRank.isCachedModel() || BatchSessionUtil.isEnabled()) {
247                 Object staleObject = session.get(DLFileRankImpl.class,
248                         dlFileRank.getPrimaryKeyObj());
249 
250                 if (staleObject != null) {
251                     session.evict(staleObject);
252                 }
253             }
254 
255             session.delete(dlFileRank);
256 
257             session.flush();
258         }
259         catch (Exception e) {
260             throw processException(e);
261         }
262         finally {
263             closeSession(session);
264         }
265 
266         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
267 
268         DLFileRankModelImpl dlFileRankModelImpl = (DLFileRankModelImpl)dlFileRank;
269 
270         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_U_F_N,
271             new Object[] {
272                 new Long(dlFileRankModelImpl.getOriginalCompanyId()),
273                 new Long(dlFileRankModelImpl.getOriginalUserId()),
274                 new Long(dlFileRankModelImpl.getOriginalFolderId()),
275                 
276             dlFileRankModelImpl.getOriginalName()
277             });
278 
279         EntityCacheUtil.removeResult(DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
280             DLFileRankImpl.class, dlFileRank.getPrimaryKey());
281 
282         return dlFileRank;
283     }
284 
285     public DLFileRank updateImpl(
286         com.liferay.portlet.documentlibrary.model.DLFileRank dlFileRank,
287         boolean merge) throws SystemException {
288         dlFileRank = toUnwrappedModel(dlFileRank);
289 
290         boolean isNew = dlFileRank.isNew();
291 
292         DLFileRankModelImpl dlFileRankModelImpl = (DLFileRankModelImpl)dlFileRank;
293 
294         Session session = null;
295 
296         try {
297             session = openSession();
298 
299             BatchSessionUtil.update(session, dlFileRank, merge);
300 
301             dlFileRank.setNew(false);
302         }
303         catch (Exception e) {
304             throw processException(e);
305         }
306         finally {
307             closeSession(session);
308         }
309 
310         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
311 
312         EntityCacheUtil.putResult(DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
313             DLFileRankImpl.class, dlFileRank.getPrimaryKey(), dlFileRank);
314 
315         if (!isNew &&
316                 ((dlFileRank.getCompanyId() != dlFileRankModelImpl.getOriginalCompanyId()) ||
317                 (dlFileRank.getUserId() != dlFileRankModelImpl.getOriginalUserId()) ||
318                 (dlFileRank.getFolderId() != dlFileRankModelImpl.getOriginalFolderId()) ||
319                 !Validator.equals(dlFileRank.getName(),
320                     dlFileRankModelImpl.getOriginalName()))) {
321             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_U_F_N,
322                 new Object[] {
323                     new Long(dlFileRankModelImpl.getOriginalCompanyId()),
324                     new Long(dlFileRankModelImpl.getOriginalUserId()),
325                     new Long(dlFileRankModelImpl.getOriginalFolderId()),
326                     
327                 dlFileRankModelImpl.getOriginalName()
328                 });
329         }
330 
331         if (isNew ||
332                 ((dlFileRank.getCompanyId() != dlFileRankModelImpl.getOriginalCompanyId()) ||
333                 (dlFileRank.getUserId() != dlFileRankModelImpl.getOriginalUserId()) ||
334                 (dlFileRank.getFolderId() != dlFileRankModelImpl.getOriginalFolderId()) ||
335                 !Validator.equals(dlFileRank.getName(),
336                     dlFileRankModelImpl.getOriginalName()))) {
337             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_U_F_N,
338                 new Object[] {
339                     new Long(dlFileRank.getCompanyId()),
340                     new Long(dlFileRank.getUserId()),
341                     new Long(dlFileRank.getFolderId()),
342                     
343                 dlFileRank.getName()
344                 }, dlFileRank);
345         }
346 
347         return dlFileRank;
348     }
349 
350     protected DLFileRank toUnwrappedModel(DLFileRank dlFileRank) {
351         if (dlFileRank instanceof DLFileRankImpl) {
352             return dlFileRank;
353         }
354 
355         DLFileRankImpl dlFileRankImpl = new DLFileRankImpl();
356 
357         dlFileRankImpl.setNew(dlFileRank.isNew());
358         dlFileRankImpl.setPrimaryKey(dlFileRank.getPrimaryKey());
359 
360         dlFileRankImpl.setFileRankId(dlFileRank.getFileRankId());
361         dlFileRankImpl.setGroupId(dlFileRank.getGroupId());
362         dlFileRankImpl.setCompanyId(dlFileRank.getCompanyId());
363         dlFileRankImpl.setUserId(dlFileRank.getUserId());
364         dlFileRankImpl.setCreateDate(dlFileRank.getCreateDate());
365         dlFileRankImpl.setFolderId(dlFileRank.getFolderId());
366         dlFileRankImpl.setName(dlFileRank.getName());
367 
368         return dlFileRankImpl;
369     }
370 
371     public DLFileRank findByPrimaryKey(Serializable primaryKey)
372         throws NoSuchModelException, SystemException {
373         return findByPrimaryKey(((Long)primaryKey).longValue());
374     }
375 
376     public DLFileRank findByPrimaryKey(long fileRankId)
377         throws NoSuchFileRankException, SystemException {
378         DLFileRank dlFileRank = fetchByPrimaryKey(fileRankId);
379 
380         if (dlFileRank == null) {
381             if (_log.isWarnEnabled()) {
382                 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + fileRankId);
383             }
384 
385             throw new NoSuchFileRankException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
386                 fileRankId);
387         }
388 
389         return dlFileRank;
390     }
391 
392     public DLFileRank fetchByPrimaryKey(Serializable primaryKey)
393         throws SystemException {
394         return fetchByPrimaryKey(((Long)primaryKey).longValue());
395     }
396 
397     public DLFileRank fetchByPrimaryKey(long fileRankId)
398         throws SystemException {
399         DLFileRank dlFileRank = (DLFileRank)EntityCacheUtil.getResult(DLFileRankModelImpl.ENTITY_CACHE_ENABLED,
400                 DLFileRankImpl.class, fileRankId, this);
401 
402         if (dlFileRank == null) {
403             Session session = null;
404 
405             try {
406                 session = openSession();
407 
408                 dlFileRank = (DLFileRank)session.get(DLFileRankImpl.class,
409                         new Long(fileRankId));
410             }
411             catch (Exception e) {
412                 throw processException(e);
413             }
414             finally {
415                 if (dlFileRank != null) {
416                     cacheResult(dlFileRank);
417                 }
418 
419                 closeSession(session);
420             }
421         }
422 
423         return dlFileRank;
424     }
425 
426     public List<DLFileRank> findByUserId(long userId) throws SystemException {
427         return findByUserId(userId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
428     }
429 
430     public List<DLFileRank> findByUserId(long userId, int start, int end)
431         throws SystemException {
432         return findByUserId(userId, start, end, null);
433     }
434 
435     public List<DLFileRank> findByUserId(long userId, int start, int end,
436         OrderByComparator orderByComparator) throws SystemException {
437         Object[] finderArgs = new Object[] {
438                 new Long(userId),
439                 
440                 String.valueOf(start), String.valueOf(end),
441                 String.valueOf(orderByComparator)
442             };
443 
444         List<DLFileRank> list = (List<DLFileRank>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_USERID,
445                 finderArgs, this);
446 
447         if (list == null) {
448             Session session = null;
449 
450             try {
451                 session = openSession();
452 
453                 StringBundler query = null;
454 
455                 if (orderByComparator != null) {
456                     query = new StringBundler(3 +
457                             (orderByComparator.getOrderByFields().length * 3));
458                 }
459                 else {
460                     query = new StringBundler(3);
461                 }
462 
463                 query.append(_SQL_SELECT_DLFILERANK_WHERE);
464 
465                 query.append(_FINDER_COLUMN_USERID_USERID_2);
466 
467                 if (orderByComparator != null) {
468                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
469                         orderByComparator);
470                 }
471 
472                 else {
473                     query.append(DLFileRankModelImpl.ORDER_BY_JPQL);
474                 }
475 
476                 String sql = query.toString();
477 
478                 Query q = session.createQuery(sql);
479 
480                 QueryPos qPos = QueryPos.getInstance(q);
481 
482                 qPos.add(userId);
483 
484                 list = (List<DLFileRank>)QueryUtil.list(q, getDialect(), start,
485                         end);
486             }
487             catch (Exception e) {
488                 throw processException(e);
489             }
490             finally {
491                 if (list == null) {
492                     list = new ArrayList<DLFileRank>();
493                 }
494 
495                 cacheResult(list);
496 
497                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_USERID,
498                     finderArgs, list);
499 
500                 closeSession(session);
501             }
502         }
503 
504         return list;
505     }
506 
507     public DLFileRank findByUserId_First(long userId,
508         OrderByComparator orderByComparator)
509         throws NoSuchFileRankException, SystemException {
510         List<DLFileRank> list = findByUserId(userId, 0, 1, orderByComparator);
511 
512         if (list.isEmpty()) {
513             StringBundler msg = new StringBundler(4);
514 
515             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
516 
517             msg.append("userId=");
518             msg.append(userId);
519 
520             msg.append(StringPool.CLOSE_CURLY_BRACE);
521 
522             throw new NoSuchFileRankException(msg.toString());
523         }
524         else {
525             return list.get(0);
526         }
527     }
528 
529     public DLFileRank findByUserId_Last(long userId,
530         OrderByComparator orderByComparator)
531         throws NoSuchFileRankException, SystemException {
532         int count = countByUserId(userId);
533 
534         List<DLFileRank> list = findByUserId(userId, count - 1, count,
535                 orderByComparator);
536 
537         if (list.isEmpty()) {
538             StringBundler msg = new StringBundler(4);
539 
540             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
541 
542             msg.append("userId=");
543             msg.append(userId);
544 
545             msg.append(StringPool.CLOSE_CURLY_BRACE);
546 
547             throw new NoSuchFileRankException(msg.toString());
548         }
549         else {
550             return list.get(0);
551         }
552     }
553 
554     public DLFileRank[] findByUserId_PrevAndNext(long fileRankId, long userId,
555         OrderByComparator orderByComparator)
556         throws NoSuchFileRankException, SystemException {
557         DLFileRank dlFileRank = findByPrimaryKey(fileRankId);
558 
559         Session session = null;
560 
561         try {
562             session = openSession();
563 
564             DLFileRank[] array = new DLFileRankImpl[3];
565 
566             array[0] = getByUserId_PrevAndNext(session, dlFileRank, userId,
567                     orderByComparator, true);
568 
569             array[1] = dlFileRank;
570 
571             array[2] = getByUserId_PrevAndNext(session, dlFileRank, userId,
572                     orderByComparator, false);
573 
574             return array;
575         }
576         catch (Exception e) {
577             throw processException(e);
578         }
579         finally {
580             closeSession(session);
581         }
582     }
583 
584     protected DLFileRank getByUserId_PrevAndNext(Session session,
585         DLFileRank dlFileRank, long userId,
586         OrderByComparator orderByComparator, boolean previous) {
587         StringBundler query = null;
588 
589         if (orderByComparator != null) {
590             query = new StringBundler(6 +
591                     (orderByComparator.getOrderByFields().length * 6));
592         }
593         else {
594             query = new StringBundler(3);
595         }
596 
597         query.append(_SQL_SELECT_DLFILERANK_WHERE);
598 
599         query.append(_FINDER_COLUMN_USERID_USERID_2);
600 
601         if (orderByComparator != null) {
602             String[] orderByFields = orderByComparator.getOrderByFields();
603 
604             if (orderByFields.length > 0) {
605                 query.append(WHERE_AND);
606             }
607 
608             for (int i = 0; i < orderByFields.length; i++) {
609                 query.append(_ORDER_BY_ENTITY_ALIAS);
610                 query.append(orderByFields[i]);
611 
612                 if ((i + 1) < orderByFields.length) {
613                     if (orderByComparator.isAscending() ^ previous) {
614                         query.append(WHERE_GREATER_THAN_HAS_NEXT);
615                     }
616                     else {
617                         query.append(WHERE_LESSER_THAN_HAS_NEXT);
618                     }
619                 }
620                 else {
621                     if (orderByComparator.isAscending() ^ previous) {
622                         query.append(WHERE_GREATER_THAN);
623                     }
624                     else {
625                         query.append(WHERE_LESSER_THAN);
626                     }
627                 }
628             }
629 
630             query.append(ORDER_BY_CLAUSE);
631 
632             for (int i = 0; i < orderByFields.length; i++) {
633                 query.append(_ORDER_BY_ENTITY_ALIAS);
634                 query.append(orderByFields[i]);
635 
636                 if ((i + 1) < orderByFields.length) {
637                     if (orderByComparator.isAscending() ^ previous) {
638                         query.append(ORDER_BY_ASC_HAS_NEXT);
639                     }
640                     else {
641                         query.append(ORDER_BY_DESC_HAS_NEXT);
642                     }
643                 }
644                 else {
645                     if (orderByComparator.isAscending() ^ previous) {
646                         query.append(ORDER_BY_ASC);
647                     }
648                     else {
649                         query.append(ORDER_BY_DESC);
650                     }
651                 }
652             }
653         }
654 
655         else {
656             query.append(DLFileRankModelImpl.ORDER_BY_JPQL);
657         }
658 
659         String sql = query.toString();
660 
661         Query q = session.createQuery(sql);
662 
663         q.setFirstResult(0);
664         q.setMaxResults(2);
665 
666         QueryPos qPos = QueryPos.getInstance(q);
667 
668         qPos.add(userId);
669 
670         if (orderByComparator != null) {
671             Object[] values = orderByComparator.getOrderByValues(dlFileRank);
672 
673             for (Object value : values) {
674                 qPos.add(value);
675             }
676         }
677 
678         List<DLFileRank> list = q.list();
679 
680         if (list.size() == 2) {
681             return list.get(1);
682         }
683         else {
684             return null;
685         }
686     }
687 
688     public List<DLFileRank> findByG_U(long groupId, long userId)
689         throws SystemException {
690         return findByG_U(groupId, userId, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
691             null);
692     }
693 
694     public List<DLFileRank> findByG_U(long groupId, long userId, int start,
695         int end) throws SystemException {
696         return findByG_U(groupId, userId, start, end, null);
697     }
698 
699     public List<DLFileRank> findByG_U(long groupId, long userId, int start,
700         int end, OrderByComparator orderByComparator) throws SystemException {
701         Object[] finderArgs = new Object[] {
702                 new Long(groupId), new Long(userId),
703                 
704                 String.valueOf(start), String.valueOf(end),
705                 String.valueOf(orderByComparator)
706             };
707 
708         List<DLFileRank> list = (List<DLFileRank>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_U,
709                 finderArgs, this);
710 
711         if (list == null) {
712             Session session = null;
713 
714             try {
715                 session = openSession();
716 
717                 StringBundler query = null;
718 
719                 if (orderByComparator != null) {
720                     query = new StringBundler(4 +
721                             (orderByComparator.getOrderByFields().length * 3));
722                 }
723                 else {
724                     query = new StringBundler(4);
725                 }
726 
727                 query.append(_SQL_SELECT_DLFILERANK_WHERE);
728 
729                 query.append(_FINDER_COLUMN_G_U_GROUPID_2);
730 
731                 query.append(_FINDER_COLUMN_G_U_USERID_2);
732 
733                 if (orderByComparator != null) {
734                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
735                         orderByComparator);
736                 }
737 
738                 else {
739                     query.append(DLFileRankModelImpl.ORDER_BY_JPQL);
740                 }
741 
742                 String sql = query.toString();
743 
744                 Query q = session.createQuery(sql);
745 
746                 QueryPos qPos = QueryPos.getInstance(q);
747 
748                 qPos.add(groupId);
749 
750                 qPos.add(userId);
751 
752                 list = (List<DLFileRank>)QueryUtil.list(q, getDialect(), start,
753                         end);
754             }
755             catch (Exception e) {
756                 throw processException(e);
757             }
758             finally {
759                 if (list == null) {
760                     list = new ArrayList<DLFileRank>();
761                 }
762 
763                 cacheResult(list);
764 
765                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_U, finderArgs,
766                     list);
767 
768                 closeSession(session);
769             }
770         }
771 
772         return list;
773     }
774 
775     public DLFileRank findByG_U_First(long groupId, long userId,
776         OrderByComparator orderByComparator)
777         throws NoSuchFileRankException, SystemException {
778         List<DLFileRank> list = findByG_U(groupId, userId, 0, 1,
779                 orderByComparator);
780 
781         if (list.isEmpty()) {
782             StringBundler msg = new StringBundler(6);
783 
784             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
785 
786             msg.append("groupId=");
787             msg.append(groupId);
788 
789             msg.append(", userId=");
790             msg.append(userId);
791 
792             msg.append(StringPool.CLOSE_CURLY_BRACE);
793 
794             throw new NoSuchFileRankException(msg.toString());
795         }
796         else {
797             return list.get(0);
798         }
799     }
800 
801     public DLFileRank findByG_U_Last(long groupId, long userId,
802         OrderByComparator orderByComparator)
803         throws NoSuchFileRankException, SystemException {
804         int count = countByG_U(groupId, userId);
805 
806         List<DLFileRank> list = findByG_U(groupId, userId, count - 1, count,
807                 orderByComparator);
808 
809         if (list.isEmpty()) {
810             StringBundler msg = new StringBundler(6);
811 
812             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
813 
814             msg.append("groupId=");
815             msg.append(groupId);
816 
817             msg.append(", userId=");
818             msg.append(userId);
819 
820             msg.append(StringPool.CLOSE_CURLY_BRACE);
821 
822             throw new NoSuchFileRankException(msg.toString());
823         }
824         else {
825             return list.get(0);
826         }
827     }
828 
829     public DLFileRank[] findByG_U_PrevAndNext(long fileRankId, long groupId,
830         long userId, OrderByComparator orderByComparator)
831         throws NoSuchFileRankException, SystemException {
832         DLFileRank dlFileRank = findByPrimaryKey(fileRankId);
833 
834         Session session = null;
835 
836         try {
837             session = openSession();
838 
839             DLFileRank[] array = new DLFileRankImpl[3];
840 
841             array[0] = getByG_U_PrevAndNext(session, dlFileRank, groupId,
842                     userId, orderByComparator, true);
843 
844             array[1] = dlFileRank;
845 
846             array[2] = getByG_U_PrevAndNext(session, dlFileRank, groupId,
847                     userId, orderByComparator, false);
848 
849             return array;
850         }
851         catch (Exception e) {
852             throw processException(e);
853         }
854         finally {
855             closeSession(session);
856         }
857     }
858 
859     protected DLFileRank getByG_U_PrevAndNext(Session session,
860         DLFileRank dlFileRank, long groupId, long userId,
861         OrderByComparator orderByComparator, boolean previous) {
862         StringBundler query = null;
863 
864         if (orderByComparator != null) {
865             query = new StringBundler(6 +
866                     (orderByComparator.getOrderByFields().length * 6));
867         }
868         else {
869             query = new StringBundler(3);
870         }
871 
872         query.append(_SQL_SELECT_DLFILERANK_WHERE);
873 
874         query.append(_FINDER_COLUMN_G_U_GROUPID_2);
875 
876         query.append(_FINDER_COLUMN_G_U_USERID_2);
877 
878         if (orderByComparator != null) {
879             String[] orderByFields = orderByComparator.getOrderByFields();
880 
881             if (orderByFields.length > 0) {
882                 query.append(WHERE_AND);
883             }
884 
885             for (int i = 0; i < orderByFields.length; i++) {
886                 query.append(_ORDER_BY_ENTITY_ALIAS);
887                 query.append(orderByFields[i]);
888 
889                 if ((i + 1) < orderByFields.length) {
890                     if (orderByComparator.isAscending() ^ previous) {
891                         query.append(WHERE_GREATER_THAN_HAS_NEXT);
892                     }
893                     else {
894                         query.append(WHERE_LESSER_THAN_HAS_NEXT);
895                     }
896                 }
897                 else {
898                     if (orderByComparator.isAscending() ^ previous) {
899                         query.append(WHERE_GREATER_THAN);
900                     }
901                     else {
902                         query.append(WHERE_LESSER_THAN);
903                     }
904                 }
905             }
906 
907             query.append(ORDER_BY_CLAUSE);
908 
909             for (int i = 0; i < orderByFields.length; i++) {
910                 query.append(_ORDER_BY_ENTITY_ALIAS);
911                 query.append(orderByFields[i]);
912 
913                 if ((i + 1) < orderByFields.length) {
914                     if (orderByComparator.isAscending() ^ previous) {
915                         query.append(ORDER_BY_ASC_HAS_NEXT);
916                     }
917                     else {
918                         query.append(ORDER_BY_DESC_HAS_NEXT);
919                     }
920                 }
921                 else {
922                     if (orderByComparator.isAscending() ^ previous) {
923                         query.append(ORDER_BY_ASC);
924                     }
925                     else {
926                         query.append(ORDER_BY_DESC);
927                     }
928                 }
929             }
930         }
931 
932         else {
933             query.append(DLFileRankModelImpl.ORDER_BY_JPQL);
934         }
935 
936         String sql = query.toString();
937 
938         Query q = session.createQuery(sql);
939 
940         q.setFirstResult(0);
941         q.setMaxResults(2);
942 
943         QueryPos qPos = QueryPos.getInstance(q);
944 
945         qPos.add(groupId);
946 
947         qPos.add(userId);
948 
949         if (orderByComparator != null) {
950             Object[] values = orderByComparator.getOrderByValues(dlFileRank);
951 
952             for (Object value : values) {
953                 qPos.add(value);
954             }
955         }
956 
957         List<DLFileRank> list = q.list();
958 
959         if (list.size() == 2) {
960             return list.get(1);
961         }
962         else {
963             return null;
964         }
965     }
966 
967     public List<DLFileRank> findByF_N(long folderId, String name)
968         throws SystemException {
969         return findByF_N(folderId, name, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
970             null);
971     }
972 
973     public List<DLFileRank> findByF_N(long folderId, String name, int start,
974         int end) throws SystemException {
975         return findByF_N(folderId, name, start, end, null);
976     }
977 
978     public List<DLFileRank> findByF_N(long folderId, String name, int start,
979         int end, OrderByComparator orderByComparator) throws SystemException {
980         Object[] finderArgs = new Object[] {
981                 new Long(folderId),
982                 
983                 name,
984                 
985                 String.valueOf(start), String.valueOf(end),
986                 String.valueOf(orderByComparator)
987             };
988 
989         List<DLFileRank> list = (List<DLFileRank>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_F_N,
990                 finderArgs, this);
991 
992         if (list == null) {
993             Session session = null;
994 
995             try {
996                 session = openSession();
997 
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_DLFILERANK_WHERE);
1009
1010                query.append(_FINDER_COLUMN_F_N_FOLDERID_2);
1011
1012                if (name == null) {
1013                    query.append(_FINDER_COLUMN_F_N_NAME_1);
1014                }
1015                else {
1016                    if (name.equals(StringPool.BLANK)) {
1017                        query.append(_FINDER_COLUMN_F_N_NAME_3);
1018                    }
1019                    else {
1020                        query.append(_FINDER_COLUMN_F_N_NAME_2);
1021                    }
1022                }
1023
1024                if (orderByComparator != null) {
1025                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1026                        orderByComparator);
1027                }
1028
1029                else {
1030                    query.append(DLFileRankModelImpl.ORDER_BY_JPQL);
1031                }
1032
1033                String sql = query.toString();
1034
1035                Query q = session.createQuery(sql);
1036
1037                QueryPos qPos = QueryPos.getInstance(q);
1038
1039                qPos.add(folderId);
1040
1041                if (name != null) {
1042                    qPos.add(name);
1043                }
1044
1045                list = (List<DLFileRank>)QueryUtil.list(q, getDialect(), start,
1046                        end);
1047            }
1048            catch (Exception e) {
1049                throw processException(e);
1050            }
1051            finally {
1052                if (list == null) {
1053                    list = new ArrayList<DLFileRank>();
1054                }
1055
1056                cacheResult(list);
1057
1058                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_F_N, finderArgs,
1059                    list);
1060
1061                closeSession(session);
1062            }
1063        }
1064
1065        return list;
1066    }
1067
1068    public DLFileRank findByF_N_First(long folderId, String name,
1069        OrderByComparator orderByComparator)
1070        throws NoSuchFileRankException, SystemException {
1071        List<DLFileRank> list = findByF_N(folderId, name, 0, 1,
1072                orderByComparator);
1073
1074        if (list.isEmpty()) {
1075            StringBundler msg = new StringBundler(6);
1076
1077            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1078
1079            msg.append("folderId=");
1080            msg.append(folderId);
1081
1082            msg.append(", name=");
1083            msg.append(name);
1084
1085            msg.append(StringPool.CLOSE_CURLY_BRACE);
1086
1087            throw new NoSuchFileRankException(msg.toString());
1088        }
1089        else {
1090            return list.get(0);
1091        }
1092    }
1093
1094    public DLFileRank findByF_N_Last(long folderId, String name,
1095        OrderByComparator orderByComparator)
1096        throws NoSuchFileRankException, SystemException {
1097        int count = countByF_N(folderId, name);
1098
1099        List<DLFileRank> list = findByF_N(folderId, name, count - 1, count,
1100                orderByComparator);
1101
1102        if (list.isEmpty()) {
1103            StringBundler msg = new StringBundler(6);
1104
1105            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1106
1107            msg.append("folderId=");
1108            msg.append(folderId);
1109
1110            msg.append(", name=");
1111            msg.append(name);
1112
1113            msg.append(StringPool.CLOSE_CURLY_BRACE);
1114
1115            throw new NoSuchFileRankException(msg.toString());
1116        }
1117        else {
1118            return list.get(0);
1119        }
1120    }
1121
1122    public DLFileRank[] findByF_N_PrevAndNext(long fileRankId, long folderId,
1123        String name, OrderByComparator orderByComparator)
1124        throws NoSuchFileRankException, SystemException {
1125        DLFileRank dlFileRank = findByPrimaryKey(fileRankId);
1126
1127        Session session = null;
1128
1129        try {
1130            session = openSession();
1131
1132            DLFileRank[] array = new DLFileRankImpl[3];
1133
1134            array[0] = getByF_N_PrevAndNext(session, dlFileRank, folderId,
1135                    name, orderByComparator, true);
1136
1137            array[1] = dlFileRank;
1138
1139            array[2] = getByF_N_PrevAndNext(session, dlFileRank, folderId,
1140                    name, orderByComparator, false);
1141
1142            return array;
1143        }
1144        catch (Exception e) {
1145            throw processException(e);
1146        }
1147        finally {
1148            closeSession(session);
1149        }
1150    }
1151
1152    protected DLFileRank getByF_N_PrevAndNext(Session session,
1153        DLFileRank dlFileRank, long folderId, String name,
1154        OrderByComparator orderByComparator, boolean previous) {
1155        StringBundler query = null;
1156
1157        if (orderByComparator != null) {
1158            query = new StringBundler(6 +
1159                    (orderByComparator.getOrderByFields().length * 6));
1160        }
1161        else {
1162            query = new StringBundler(3);
1163        }
1164
1165        query.append(_SQL_SELECT_DLFILERANK_WHERE);
1166
1167        query.append(_FINDER_COLUMN_F_N_FOLDERID_2);
1168
1169        if (name == null) {
1170            query.append(_FINDER_COLUMN_F_N_NAME_1);
1171        }
1172        else {
1173            if (name.equals(StringPool.BLANK)) {
1174                query.append(_FINDER_COLUMN_F_N_NAME_3);
1175            }
1176            else {
1177                query.append(_FINDER_COLUMN_F_N_NAME_2);
1178            }
1179        }
1180
1181        if (orderByComparator != null) {
1182            String[] orderByFields = orderByComparator.getOrderByFields();
1183
1184            if (orderByFields.length > 0) {
1185                query.append(WHERE_AND);
1186            }
1187
1188            for (int i = 0; i < orderByFields.length; i++) {
1189                query.append(_ORDER_BY_ENTITY_ALIAS);
1190                query.append(orderByFields[i]);
1191
1192                if ((i + 1) < orderByFields.length) {
1193                    if (orderByComparator.isAscending() ^ previous) {
1194                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
1195                    }
1196                    else {
1197                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
1198                    }
1199                }
1200                else {
1201                    if (orderByComparator.isAscending() ^ previous) {
1202                        query.append(WHERE_GREATER_THAN);
1203                    }
1204                    else {
1205                        query.append(WHERE_LESSER_THAN);
1206                    }
1207                }
1208            }
1209
1210            query.append(ORDER_BY_CLAUSE);
1211
1212            for (int i = 0; i < orderByFields.length; i++) {
1213                query.append(_ORDER_BY_ENTITY_ALIAS);
1214                query.append(orderByFields[i]);
1215
1216                if ((i + 1) < orderByFields.length) {
1217                    if (orderByComparator.isAscending() ^ previous) {
1218                        query.append(ORDER_BY_ASC_HAS_NEXT);
1219                    }
1220                    else {
1221                        query.append(ORDER_BY_DESC_HAS_NEXT);
1222                    }
1223                }
1224                else {
1225                    if (orderByComparator.isAscending() ^ previous) {
1226                        query.append(ORDER_BY_ASC);
1227                    }
1228                    else {
1229                        query.append(ORDER_BY_DESC);
1230                    }
1231                }
1232            }
1233        }
1234
1235        else {
1236            query.append(DLFileRankModelImpl.ORDER_BY_JPQL);
1237        }
1238
1239        String sql = query.toString();
1240
1241        Query q = session.createQuery(sql);
1242
1243        q.setFirstResult(0);
1244        q.setMaxResults(2);
1245
1246        QueryPos qPos = QueryPos.getInstance(q);
1247
1248        qPos.add(folderId);
1249
1250        if (name != null) {
1251            qPos.add(name);
1252        }
1253
1254        if (orderByComparator != null) {
1255            Object[] values = orderByComparator.getOrderByValues(dlFileRank);
1256
1257            for (Object value : values) {
1258                qPos.add(value);
1259            }
1260        }
1261
1262        List<DLFileRank> list = q.list();
1263
1264        if (list.size() == 2) {
1265            return list.get(1);
1266        }
1267        else {
1268            return null;
1269        }
1270    }
1271
1272    public DLFileRank findByC_U_F_N(long companyId, long userId, long folderId,
1273        String name) throws NoSuchFileRankException, SystemException {
1274        DLFileRank dlFileRank = fetchByC_U_F_N(companyId, userId, folderId, name);
1275
1276        if (dlFileRank == null) {
1277            StringBundler msg = new StringBundler(10);
1278
1279            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1280
1281            msg.append("companyId=");
1282            msg.append(companyId);
1283
1284            msg.append(", userId=");
1285            msg.append(userId);
1286
1287            msg.append(", folderId=");
1288            msg.append(folderId);
1289
1290            msg.append(", name=");
1291            msg.append(name);
1292
1293            msg.append(StringPool.CLOSE_CURLY_BRACE);
1294
1295            if (_log.isWarnEnabled()) {
1296                _log.warn(msg.toString());
1297            }
1298
1299            throw new NoSuchFileRankException(msg.toString());
1300        }
1301
1302        return dlFileRank;
1303    }
1304
1305    public DLFileRank fetchByC_U_F_N(long companyId, long userId,
1306        long folderId, String name) throws SystemException {
1307        return fetchByC_U_F_N(companyId, userId, folderId, name, true);
1308    }
1309
1310    public DLFileRank fetchByC_U_F_N(long companyId, long userId,
1311        long folderId, String name, boolean retrieveFromCache)
1312        throws SystemException {
1313        Object[] finderArgs = new Object[] {
1314                new Long(companyId), new Long(userId), new Long(folderId),
1315                
1316                name
1317            };
1318
1319        Object result = null;
1320
1321        if (retrieveFromCache) {
1322            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_C_U_F_N,
1323                    finderArgs, this);
1324        }
1325
1326        if (result == null) {
1327            Session session = null;
1328
1329            try {
1330                session = openSession();
1331
1332                StringBundler query = new StringBundler(6);
1333
1334                query.append(_SQL_SELECT_DLFILERANK_WHERE);
1335
1336                query.append(_FINDER_COLUMN_C_U_F_N_COMPANYID_2);
1337
1338                query.append(_FINDER_COLUMN_C_U_F_N_USERID_2);
1339
1340                query.append(_FINDER_COLUMN_C_U_F_N_FOLDERID_2);
1341
1342                if (name == null) {
1343                    query.append(_FINDER_COLUMN_C_U_F_N_NAME_1);
1344                }
1345                else {
1346                    if (name.equals(StringPool.BLANK)) {
1347                        query.append(_FINDER_COLUMN_C_U_F_N_NAME_3);
1348                    }
1349                    else {
1350                        query.append(_FINDER_COLUMN_C_U_F_N_NAME_2);
1351                    }
1352                }
1353
1354                query.append(DLFileRankModelImpl.ORDER_BY_JPQL);
1355
1356                String sql = query.toString();
1357
1358                Query q = session.createQuery(sql);
1359
1360                QueryPos qPos = QueryPos.getInstance(q);
1361
1362                qPos.add(companyId);
1363
1364                qPos.add(userId);
1365
1366                qPos.add(folderId);
1367
1368                if (name != null) {
1369                    qPos.add(name);
1370                }
1371
1372                List<DLFileRank> list = q.list();
1373
1374                result = list;
1375
1376                DLFileRank dlFileRank = null;
1377
1378                if (list.isEmpty()) {
1379                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_U_F_N,
1380                        finderArgs, list);
1381                }
1382                else {
1383                    dlFileRank = list.get(0);
1384
1385                    cacheResult(dlFileRank);
1386
1387                    if ((dlFileRank.getCompanyId() != companyId) ||
1388                            (dlFileRank.getUserId() != userId) ||
1389                            (dlFileRank.getFolderId() != folderId) ||
1390                            (dlFileRank.getName() == null) ||
1391                            !dlFileRank.getName().equals(name)) {
1392                        FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_U_F_N,
1393                            finderArgs, dlFileRank);
1394                    }
1395                }
1396
1397                return dlFileRank;
1398            }
1399            catch (Exception e) {
1400                throw processException(e);
1401            }
1402            finally {
1403                if (result == null) {
1404                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_U_F_N,
1405                        finderArgs, new ArrayList<DLFileRank>());
1406                }
1407
1408                closeSession(session);
1409            }
1410        }
1411        else {
1412            if (result instanceof List<?>) {
1413                return null;
1414            }
1415            else {
1416                return (DLFileRank)result;
1417            }
1418        }
1419    }
1420
1421    public List<DLFileRank> findAll() throws SystemException {
1422        return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1423    }
1424
1425    public List<DLFileRank> findAll(int start, int end)
1426        throws SystemException {
1427        return findAll(start, end, null);
1428    }
1429
1430    public List<DLFileRank> findAll(int start, int end,
1431        OrderByComparator orderByComparator) throws SystemException {
1432        Object[] finderArgs = new Object[] {
1433                String.valueOf(start), String.valueOf(end),
1434                String.valueOf(orderByComparator)
1435            };
1436
1437        List<DLFileRank> list = (List<DLFileRank>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
1438                finderArgs, this);
1439
1440        if (list == null) {
1441            Session session = null;
1442
1443            try {
1444                session = openSession();
1445
1446                StringBundler query = null;
1447                String sql = null;
1448
1449                if (orderByComparator != null) {
1450                    query = new StringBundler(2 +
1451                            (orderByComparator.getOrderByFields().length * 3));
1452
1453                    query.append(_SQL_SELECT_DLFILERANK);
1454
1455                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1456                        orderByComparator);
1457
1458                    sql = query.toString();
1459                }
1460
1461                else {
1462                    sql = _SQL_SELECT_DLFILERANK.concat(DLFileRankModelImpl.ORDER_BY_JPQL);
1463                }
1464
1465                Query q = session.createQuery(sql);
1466
1467                if (orderByComparator == null) {
1468                    list = (List<DLFileRank>)QueryUtil.list(q, getDialect(),
1469                            start, end, false);
1470
1471                    Collections.sort(list);
1472                }
1473                else {
1474                    list = (List<DLFileRank>)QueryUtil.list(q, getDialect(),
1475                            start, end);
1476                }
1477            }
1478            catch (Exception e) {
1479                throw processException(e);
1480            }
1481            finally {
1482                if (list == null) {
1483                    list = new ArrayList<DLFileRank>();
1484                }
1485
1486                cacheResult(list);
1487
1488                FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
1489
1490                closeSession(session);
1491            }
1492        }
1493
1494        return list;
1495    }
1496
1497    public void removeByUserId(long userId) throws SystemException {
1498        for (DLFileRank dlFileRank : findByUserId(userId)) {
1499            remove(dlFileRank);
1500        }
1501    }
1502
1503    public void removeByG_U(long groupId, long userId)
1504        throws SystemException {
1505        for (DLFileRank dlFileRank : findByG_U(groupId, userId)) {
1506            remove(dlFileRank);
1507        }
1508    }
1509
1510    public void removeByF_N(long folderId, String name)
1511        throws SystemException {
1512        for (DLFileRank dlFileRank : findByF_N(folderId, name)) {
1513            remove(dlFileRank);
1514        }
1515    }
1516
1517    public void removeByC_U_F_N(long companyId, long userId, long folderId,
1518        String name) throws NoSuchFileRankException, SystemException {
1519        DLFileRank dlFileRank = findByC_U_F_N(companyId, userId, folderId, name);
1520
1521        remove(dlFileRank);
1522    }
1523
1524    public void removeAll() throws SystemException {
1525        for (DLFileRank dlFileRank : findAll()) {
1526            remove(dlFileRank);
1527        }
1528    }
1529
1530    public int countByUserId(long userId) throws SystemException {
1531        Object[] finderArgs = new Object[] { new Long(userId) };
1532
1533        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_USERID,
1534                finderArgs, this);
1535
1536        if (count == null) {
1537            Session session = null;
1538
1539            try {
1540                session = openSession();
1541
1542                StringBundler query = new StringBundler(2);
1543
1544                query.append(_SQL_COUNT_DLFILERANK_WHERE);
1545
1546                query.append(_FINDER_COLUMN_USERID_USERID_2);
1547
1548                String sql = query.toString();
1549
1550                Query q = session.createQuery(sql);
1551
1552                QueryPos qPos = QueryPos.getInstance(q);
1553
1554                qPos.add(userId);
1555
1556                count = (Long)q.uniqueResult();
1557            }
1558            catch (Exception e) {
1559                throw processException(e);
1560            }
1561            finally {
1562                if (count == null) {
1563                    count = Long.valueOf(0);
1564                }
1565
1566                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_USERID,
1567                    finderArgs, count);
1568
1569                closeSession(session);
1570            }
1571        }
1572
1573        return count.intValue();
1574    }
1575
1576    public int countByG_U(long groupId, long userId) throws SystemException {
1577        Object[] finderArgs = new Object[] { new Long(groupId), new Long(userId) };
1578
1579        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_U,
1580                finderArgs, this);
1581
1582        if (count == null) {
1583            Session session = null;
1584
1585            try {
1586                session = openSession();
1587
1588                StringBundler query = new StringBundler(3);
1589
1590                query.append(_SQL_COUNT_DLFILERANK_WHERE);
1591
1592                query.append(_FINDER_COLUMN_G_U_GROUPID_2);
1593
1594                query.append(_FINDER_COLUMN_G_U_USERID_2);
1595
1596                String sql = query.toString();
1597
1598                Query q = session.createQuery(sql);
1599
1600                QueryPos qPos = QueryPos.getInstance(q);
1601
1602                qPos.add(groupId);
1603
1604                qPos.add(userId);
1605
1606                count = (Long)q.uniqueResult();
1607            }
1608            catch (Exception e) {
1609                throw processException(e);
1610            }
1611            finally {
1612                if (count == null) {
1613                    count = Long.valueOf(0);
1614                }
1615
1616                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_U, finderArgs,
1617                    count);
1618
1619                closeSession(session);
1620            }
1621        }
1622
1623        return count.intValue();
1624    }
1625
1626    public int countByF_N(long folderId, String name) throws SystemException {
1627        Object[] finderArgs = new Object[] { new Long(folderId), name };
1628
1629        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_F_N,
1630                finderArgs, this);
1631
1632        if (count == null) {
1633            Session session = null;
1634
1635            try {
1636                session = openSession();
1637
1638                StringBundler query = new StringBundler(3);
1639
1640                query.append(_SQL_COUNT_DLFILERANK_WHERE);
1641
1642                query.append(_FINDER_COLUMN_F_N_FOLDERID_2);
1643
1644                if (name == null) {
1645                    query.append(_FINDER_COLUMN_F_N_NAME_1);
1646                }
1647                else {
1648                    if (name.equals(StringPool.BLANK)) {
1649                        query.append(_FINDER_COLUMN_F_N_NAME_3);
1650                    }
1651                    else {
1652                        query.append(_FINDER_COLUMN_F_N_NAME_2);
1653                    }
1654                }
1655
1656                String sql = query.toString();
1657
1658                Query q = session.createQuery(sql);
1659
1660                QueryPos qPos = QueryPos.getInstance(q);
1661
1662                qPos.add(folderId);
1663
1664                if (name != null) {
1665                    qPos.add(name);
1666                }
1667
1668                count = (Long)q.uniqueResult();
1669            }
1670            catch (Exception e) {
1671                throw processException(e);
1672            }
1673            finally {
1674                if (count == null) {
1675                    count = Long.valueOf(0);
1676                }
1677
1678                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_F_N, finderArgs,
1679                    count);
1680
1681                closeSession(session);
1682            }
1683        }
1684
1685        return count.intValue();
1686    }
1687
1688    public int countByC_U_F_N(long companyId, long userId, long folderId,
1689        String name) throws SystemException {
1690        Object[] finderArgs = new Object[] {
1691                new Long(companyId), new Long(userId), new Long(folderId),
1692                
1693                name
1694            };
1695
1696        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_U_F_N,
1697                finderArgs, this);
1698
1699        if (count == null) {
1700            Session session = null;
1701
1702            try {
1703                session = openSession();
1704
1705                StringBundler query = new StringBundler(5);
1706
1707                query.append(_SQL_COUNT_DLFILERANK_WHERE);
1708
1709                query.append(_FINDER_COLUMN_C_U_F_N_COMPANYID_2);
1710
1711                query.append(_FINDER_COLUMN_C_U_F_N_USERID_2);
1712
1713                query.append(_FINDER_COLUMN_C_U_F_N_FOLDERID_2);
1714
1715                if (name == null) {
1716                    query.append(_FINDER_COLUMN_C_U_F_N_NAME_1);
1717                }
1718                else {
1719                    if (name.equals(StringPool.BLANK)) {
1720                        query.append(_FINDER_COLUMN_C_U_F_N_NAME_3);
1721                    }
1722                    else {
1723                        query.append(_FINDER_COLUMN_C_U_F_N_NAME_2);
1724                    }
1725                }
1726
1727                String sql = query.toString();
1728
1729                Query q = session.createQuery(sql);
1730
1731                QueryPos qPos = QueryPos.getInstance(q);
1732
1733                qPos.add(companyId);
1734
1735                qPos.add(userId);
1736
1737                qPos.add(folderId);
1738
1739                if (name != null) {
1740                    qPos.add(name);
1741                }
1742
1743                count = (Long)q.uniqueResult();
1744            }
1745            catch (Exception e) {
1746                throw processException(e);
1747            }
1748            finally {
1749                if (count == null) {
1750                    count = Long.valueOf(0);
1751                }
1752
1753                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_U_F_N,
1754                    finderArgs, count);
1755
1756                closeSession(session);
1757            }
1758        }
1759
1760        return count.intValue();
1761    }
1762
1763    public int countAll() throws SystemException {
1764        Object[] finderArgs = new Object[0];
1765
1766        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
1767                finderArgs, this);
1768
1769        if (count == null) {
1770            Session session = null;
1771
1772            try {
1773                session = openSession();
1774
1775                Query q = session.createQuery(_SQL_COUNT_DLFILERANK);
1776
1777                count = (Long)q.uniqueResult();
1778            }
1779            catch (Exception e) {
1780                throw processException(e);
1781            }
1782            finally {
1783                if (count == null) {
1784                    count = Long.valueOf(0);
1785                }
1786
1787                FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
1788                    count);
1789
1790                closeSession(session);
1791            }
1792        }
1793
1794        return count.intValue();
1795    }
1796
1797    public void afterPropertiesSet() {
1798        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
1799                    com.liferay.portal.util.PropsUtil.get(
1800                        "value.object.listener.com.liferay.portlet.documentlibrary.model.DLFileRank")));
1801
1802        if (listenerClassNames.length > 0) {
1803            try {
1804                List<ModelListener<DLFileRank>> listenersList = new ArrayList<ModelListener<DLFileRank>>();
1805
1806                for (String listenerClassName : listenerClassNames) {
1807                    listenersList.add((ModelListener<DLFileRank>)InstanceFactory.newInstance(
1808                            listenerClassName));
1809                }
1810
1811                listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
1812            }
1813            catch (Exception e) {
1814                _log.error(e);
1815            }
1816        }
1817    }
1818
1819    @BeanReference(type = DLFileEntryPersistence.class)
1820    protected DLFileEntryPersistence dlFileEntryPersistence;
1821    @BeanReference(type = DLFileRankPersistence.class)
1822    protected DLFileRankPersistence dlFileRankPersistence;
1823    @BeanReference(type = DLFileShortcutPersistence.class)
1824    protected DLFileShortcutPersistence dlFileShortcutPersistence;
1825    @BeanReference(type = DLFileVersionPersistence.class)
1826    protected DLFileVersionPersistence dlFileVersionPersistence;
1827    @BeanReference(type = DLFolderPersistence.class)
1828    protected DLFolderPersistence dlFolderPersistence;
1829    @BeanReference(type = LayoutPersistence.class)
1830    protected LayoutPersistence layoutPersistence;
1831    @BeanReference(type = ResourcePersistence.class)
1832    protected ResourcePersistence resourcePersistence;
1833    @BeanReference(type = UserPersistence.class)
1834    protected UserPersistence userPersistence;
1835    private static final String _SQL_SELECT_DLFILERANK = "SELECT dlFileRank FROM DLFileRank dlFileRank";
1836    private static final String _SQL_SELECT_DLFILERANK_WHERE = "SELECT dlFileRank FROM DLFileRank dlFileRank WHERE ";
1837    private static final String _SQL_COUNT_DLFILERANK = "SELECT COUNT(dlFileRank) FROM DLFileRank dlFileRank";
1838    private static final String _SQL_COUNT_DLFILERANK_WHERE = "SELECT COUNT(dlFileRank) FROM DLFileRank dlFileRank WHERE ";
1839    private static final String _FINDER_COLUMN_USERID_USERID_2 = "dlFileRank.userId = ?";
1840    private static final String _FINDER_COLUMN_G_U_GROUPID_2 = "dlFileRank.groupId = ? AND ";
1841    private static final String _FINDER_COLUMN_G_U_USERID_2 = "dlFileRank.userId = ?";
1842    private static final String _FINDER_COLUMN_F_N_FOLDERID_2 = "dlFileRank.folderId = ? AND ";
1843    private static final String _FINDER_COLUMN_F_N_NAME_1 = "dlFileRank.name IS NULL";
1844    private static final String _FINDER_COLUMN_F_N_NAME_2 = "dlFileRank.name = ?";
1845    private static final String _FINDER_COLUMN_F_N_NAME_3 = "(dlFileRank.name IS NULL OR dlFileRank.name = ?)";
1846    private static final String _FINDER_COLUMN_C_U_F_N_COMPANYID_2 = "dlFileRank.companyId = ? AND ";
1847    private static final String _FINDER_COLUMN_C_U_F_N_USERID_2 = "dlFileRank.userId = ? AND ";
1848    private static final String _FINDER_COLUMN_C_U_F_N_FOLDERID_2 = "dlFileRank.folderId = ? AND ";
1849    private static final String _FINDER_COLUMN_C_U_F_N_NAME_1 = "dlFileRank.name IS NULL";
1850    private static final String _FINDER_COLUMN_C_U_F_N_NAME_2 = "dlFileRank.name = ?";
1851    private static final String _FINDER_COLUMN_C_U_F_N_NAME_3 = "(dlFileRank.name IS NULL OR dlFileRank.name = ?)";
1852    private static final String _ORDER_BY_ENTITY_ALIAS = "dlFileRank.";
1853    private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No DLFileRank exists with the primary key ";
1854    private static final String _NO_SUCH_ENTITY_WITH_KEY = "No DLFileRank exists with the key {";
1855    private static Log _log = LogFactoryUtil.getLog(DLFileRankPersistenceImpl.class);
1856}