1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * The contents of this file are subject to the terms of the Liferay Enterprise
5    * Subscription License ("License"). You may not use this file except in
6    * compliance with the License. You can obtain a copy of the License by
7    * contacting Liferay, Inc. See the License for the specific language governing
8    * permissions and limitations under the License, including but not limited to
9    * distribution rights of the Software.
10   *
11   *
12   *
13   */
14  
15  package com.liferay.portlet.wiki.service.persistence;
16  
17  import com.liferay.portal.NoSuchModelException;
18  import com.liferay.portal.SystemException;
19  import com.liferay.portal.kernel.annotation.BeanReference;
20  import com.liferay.portal.kernel.cache.CacheRegistry;
21  import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
22  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
23  import com.liferay.portal.kernel.dao.orm.FinderPath;
24  import com.liferay.portal.kernel.dao.orm.Query;
25  import com.liferay.portal.kernel.dao.orm.QueryPos;
26  import com.liferay.portal.kernel.dao.orm.QueryUtil;
27  import com.liferay.portal.kernel.dao.orm.Session;
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.kernel.uuid.PortalUUIDUtil;
38  import com.liferay.portal.model.ModelListener;
39  import com.liferay.portal.service.persistence.BatchSessionUtil;
40  import com.liferay.portal.service.persistence.CompanyPersistence;
41  import com.liferay.portal.service.persistence.GroupPersistence;
42  import com.liferay.portal.service.persistence.PortletPreferencesPersistence;
43  import com.liferay.portal.service.persistence.ResourcePersistence;
44  import com.liferay.portal.service.persistence.SubscriptionPersistence;
45  import com.liferay.portal.service.persistence.UserPersistence;
46  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
47  
48  import com.liferay.portlet.messageboards.service.persistence.MBMessagePersistence;
49  import com.liferay.portlet.social.service.persistence.SocialActivityPersistence;
50  import com.liferay.portlet.tags.service.persistence.TagsAssetPersistence;
51  import com.liferay.portlet.tags.service.persistence.TagsEntryPersistence;
52  import com.liferay.portlet.wiki.NoSuchPageException;
53  import com.liferay.portlet.wiki.model.WikiPage;
54  import com.liferay.portlet.wiki.model.impl.WikiPageImpl;
55  import com.liferay.portlet.wiki.model.impl.WikiPageModelImpl;
56  
57  import java.io.Serializable;
58  
59  import java.util.ArrayList;
60  import java.util.Collections;
61  import java.util.List;
62  
63  /**
64   * <a href="WikiPagePersistenceImpl.java.html"><b><i>View Source</i></b></a>
65   *
66   * <p>
67   * ServiceBuilder generated this class. Modifications in this class will be
68   * overwritten the next time is generated.
69   * </p>
70   *
71   * @author    Brian Wing Shun Chan
72   * @see       WikiPagePersistence
73   * @see       WikiPageUtil
74   * @generated
75   */
76  public class WikiPagePersistenceImpl extends BasePersistenceImpl<WikiPage>
77      implements WikiPagePersistence {
78      public static final String FINDER_CLASS_NAME_ENTITY = WikiPageImpl.class.getName();
79      public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
80          ".List";
81      public static final FinderPath FINDER_PATH_FIND_BY_UUID = new FinderPath(WikiPageModelImpl.ENTITY_CACHE_ENABLED,
82              WikiPageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
83              "findByUuid",
84              new String[] {
85                  String.class.getName(),
86                  
87              "java.lang.Integer", "java.lang.Integer",
88                  "com.liferay.portal.kernel.util.OrderByComparator"
89              });
90      public static final FinderPath FINDER_PATH_COUNT_BY_UUID = new FinderPath(WikiPageModelImpl.ENTITY_CACHE_ENABLED,
91              WikiPageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
92              "countByUuid", new String[] { String.class.getName() });
93      public static final FinderPath FINDER_PATH_FETCH_BY_UUID_G = new FinderPath(WikiPageModelImpl.ENTITY_CACHE_ENABLED,
94              WikiPageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_ENTITY,
95              "fetchByUUID_G",
96              new String[] { String.class.getName(), Long.class.getName() });
97      public static final FinderPath FINDER_PATH_COUNT_BY_UUID_G = new FinderPath(WikiPageModelImpl.ENTITY_CACHE_ENABLED,
98              WikiPageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
99              "countByUUID_G",
100             new String[] { String.class.getName(), Long.class.getName() });
101     public static final FinderPath FINDER_PATH_FIND_BY_NODEID = new FinderPath(WikiPageModelImpl.ENTITY_CACHE_ENABLED,
102             WikiPageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
103             "findByNodeId",
104             new String[] {
105                 Long.class.getName(),
106                 
107             "java.lang.Integer", "java.lang.Integer",
108                 "com.liferay.portal.kernel.util.OrderByComparator"
109             });
110     public static final FinderPath FINDER_PATH_COUNT_BY_NODEID = new FinderPath(WikiPageModelImpl.ENTITY_CACHE_ENABLED,
111             WikiPageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
112             "countByNodeId", new String[] { Long.class.getName() });
113     public static final FinderPath FINDER_PATH_FIND_BY_FORMAT = new FinderPath(WikiPageModelImpl.ENTITY_CACHE_ENABLED,
114             WikiPageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
115             "findByFormat",
116             new String[] {
117                 String.class.getName(),
118                 
119             "java.lang.Integer", "java.lang.Integer",
120                 "com.liferay.portal.kernel.util.OrderByComparator"
121             });
122     public static final FinderPath FINDER_PATH_COUNT_BY_FORMAT = new FinderPath(WikiPageModelImpl.ENTITY_CACHE_ENABLED,
123             WikiPageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
124             "countByFormat", new String[] { String.class.getName() });
125     public static final FinderPath FINDER_PATH_FIND_BY_N_T = new FinderPath(WikiPageModelImpl.ENTITY_CACHE_ENABLED,
126             WikiPageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
127             "findByN_T",
128             new String[] {
129                 Long.class.getName(), String.class.getName(),
130                 
131             "java.lang.Integer", "java.lang.Integer",
132                 "com.liferay.portal.kernel.util.OrderByComparator"
133             });
134     public static final FinderPath FINDER_PATH_COUNT_BY_N_T = new FinderPath(WikiPageModelImpl.ENTITY_CACHE_ENABLED,
135             WikiPageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
136             "countByN_T",
137             new String[] { Long.class.getName(), String.class.getName() });
138     public static final FinderPath FINDER_PATH_FIND_BY_N_H = new FinderPath(WikiPageModelImpl.ENTITY_CACHE_ENABLED,
139             WikiPageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
140             "findByN_H",
141             new String[] {
142                 Long.class.getName(), Boolean.class.getName(),
143                 
144             "java.lang.Integer", "java.lang.Integer",
145                 "com.liferay.portal.kernel.util.OrderByComparator"
146             });
147     public static final FinderPath FINDER_PATH_COUNT_BY_N_H = new FinderPath(WikiPageModelImpl.ENTITY_CACHE_ENABLED,
148             WikiPageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
149             "countByN_H",
150             new String[] { Long.class.getName(), Boolean.class.getName() });
151     public static final FinderPath FINDER_PATH_FIND_BY_N_P = new FinderPath(WikiPageModelImpl.ENTITY_CACHE_ENABLED,
152             WikiPageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
153             "findByN_P",
154             new String[] {
155                 Long.class.getName(), String.class.getName(),
156                 
157             "java.lang.Integer", "java.lang.Integer",
158                 "com.liferay.portal.kernel.util.OrderByComparator"
159             });
160     public static final FinderPath FINDER_PATH_COUNT_BY_N_P = new FinderPath(WikiPageModelImpl.ENTITY_CACHE_ENABLED,
161             WikiPageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
162             "countByN_P",
163             new String[] { Long.class.getName(), String.class.getName() });
164     public static final FinderPath FINDER_PATH_FIND_BY_N_R = new FinderPath(WikiPageModelImpl.ENTITY_CACHE_ENABLED,
165             WikiPageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
166             "findByN_R",
167             new String[] {
168                 Long.class.getName(), String.class.getName(),
169                 
170             "java.lang.Integer", "java.lang.Integer",
171                 "com.liferay.portal.kernel.util.OrderByComparator"
172             });
173     public static final FinderPath FINDER_PATH_COUNT_BY_N_R = new FinderPath(WikiPageModelImpl.ENTITY_CACHE_ENABLED,
174             WikiPageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
175             "countByN_R",
176             new String[] { Long.class.getName(), String.class.getName() });
177     public static final FinderPath FINDER_PATH_FETCH_BY_N_T_V = new FinderPath(WikiPageModelImpl.ENTITY_CACHE_ENABLED,
178             WikiPageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_ENTITY,
179             "fetchByN_T_V",
180             new String[] {
181                 Long.class.getName(), String.class.getName(),
182                 Double.class.getName()
183             });
184     public static final FinderPath FINDER_PATH_COUNT_BY_N_T_V = new FinderPath(WikiPageModelImpl.ENTITY_CACHE_ENABLED,
185             WikiPageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
186             "countByN_T_V",
187             new String[] {
188                 Long.class.getName(), String.class.getName(),
189                 Double.class.getName()
190             });
191     public static final FinderPath FINDER_PATH_FIND_BY_N_T_H = new FinderPath(WikiPageModelImpl.ENTITY_CACHE_ENABLED,
192             WikiPageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
193             "findByN_T_H",
194             new String[] {
195                 Long.class.getName(), String.class.getName(),
196                 Boolean.class.getName(),
197                 
198             "java.lang.Integer", "java.lang.Integer",
199                 "com.liferay.portal.kernel.util.OrderByComparator"
200             });
201     public static final FinderPath FINDER_PATH_COUNT_BY_N_T_H = new FinderPath(WikiPageModelImpl.ENTITY_CACHE_ENABLED,
202             WikiPageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
203             "countByN_T_H",
204             new String[] {
205                 Long.class.getName(), String.class.getName(),
206                 Boolean.class.getName()
207             });
208     public static final FinderPath FINDER_PATH_FIND_BY_N_H_P = new FinderPath(WikiPageModelImpl.ENTITY_CACHE_ENABLED,
209             WikiPageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
210             "findByN_H_P",
211             new String[] {
212                 Long.class.getName(), Boolean.class.getName(),
213                 String.class.getName(),
214                 
215             "java.lang.Integer", "java.lang.Integer",
216                 "com.liferay.portal.kernel.util.OrderByComparator"
217             });
218     public static final FinderPath FINDER_PATH_COUNT_BY_N_H_P = new FinderPath(WikiPageModelImpl.ENTITY_CACHE_ENABLED,
219             WikiPageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
220             "countByN_H_P",
221             new String[] {
222                 Long.class.getName(), Boolean.class.getName(),
223                 String.class.getName()
224             });
225     public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(WikiPageModelImpl.ENTITY_CACHE_ENABLED,
226             WikiPageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
227             "findAll", new String[0]);
228     public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(WikiPageModelImpl.ENTITY_CACHE_ENABLED,
229             WikiPageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
230             "countAll", new String[0]);
231 
232     public void cacheResult(WikiPage wikiPage) {
233         EntityCacheUtil.putResult(WikiPageModelImpl.ENTITY_CACHE_ENABLED,
234             WikiPageImpl.class, wikiPage.getPrimaryKey(), wikiPage);
235 
236         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
237             new Object[] { wikiPage.getUuid(), new Long(wikiPage.getGroupId()) },
238             wikiPage);
239 
240         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_N_T_V,
241             new Object[] {
242                 new Long(wikiPage.getNodeId()),
243                 
244             wikiPage.getTitle(), new Double(wikiPage.getVersion())
245             }, wikiPage);
246     }
247 
248     public void cacheResult(List<WikiPage> wikiPages) {
249         for (WikiPage wikiPage : wikiPages) {
250             if (EntityCacheUtil.getResult(
251                         WikiPageModelImpl.ENTITY_CACHE_ENABLED,
252                         WikiPageImpl.class, wikiPage.getPrimaryKey(), this) == null) {
253                 cacheResult(wikiPage);
254             }
255         }
256     }
257 
258     public void clearCache() {
259         CacheRegistry.clear(WikiPageImpl.class.getName());
260         EntityCacheUtil.clearCache(WikiPageImpl.class.getName());
261         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
262         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
263     }
264 
265     public void clearCache(WikiPage wikiPage) {
266         EntityCacheUtil.removeResult(WikiPageModelImpl.ENTITY_CACHE_ENABLED,
267             WikiPageImpl.class, wikiPage.getPrimaryKey());
268 
269         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
270             new Object[] { wikiPage.getUuid(), new Long(wikiPage.getGroupId()) });
271 
272         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_N_T_V,
273             new Object[] {
274                 new Long(wikiPage.getNodeId()),
275                 
276             wikiPage.getTitle(), new Double(wikiPage.getVersion())
277             });
278     }
279 
280     public WikiPage create(long pageId) {
281         WikiPage wikiPage = new WikiPageImpl();
282 
283         wikiPage.setNew(true);
284         wikiPage.setPrimaryKey(pageId);
285 
286         String uuid = PortalUUIDUtil.generate();
287 
288         wikiPage.setUuid(uuid);
289 
290         return wikiPage;
291     }
292 
293     public WikiPage remove(Serializable primaryKey)
294         throws NoSuchModelException, SystemException {
295         return remove(((Long)primaryKey).longValue());
296     }
297 
298     public WikiPage remove(long pageId)
299         throws NoSuchPageException, SystemException {
300         Session session = null;
301 
302         try {
303             session = openSession();
304 
305             WikiPage wikiPage = (WikiPage)session.get(WikiPageImpl.class,
306                     new Long(pageId));
307 
308             if (wikiPage == null) {
309                 if (_log.isWarnEnabled()) {
310                     _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + pageId);
311                 }
312 
313                 throw new NoSuchPageException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
314                     pageId);
315             }
316 
317             return remove(wikiPage);
318         }
319         catch (NoSuchPageException nsee) {
320             throw nsee;
321         }
322         catch (Exception e) {
323             throw processException(e);
324         }
325         finally {
326             closeSession(session);
327         }
328     }
329 
330     protected WikiPage removeImpl(WikiPage wikiPage) throws SystemException {
331         wikiPage = toUnwrappedModel(wikiPage);
332 
333         Session session = null;
334 
335         try {
336             session = openSession();
337 
338             BatchSessionUtil.delete(session, wikiPage);
339         }
340         catch (Exception e) {
341             throw processException(e);
342         }
343         finally {
344             closeSession(session);
345         }
346 
347         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
348 
349         WikiPageModelImpl wikiPageModelImpl = (WikiPageModelImpl)wikiPage;
350 
351         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
352             new Object[] {
353                 wikiPageModelImpl.getOriginalUuid(),
354                 new Long(wikiPageModelImpl.getOriginalGroupId())
355             });
356 
357         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_N_T_V,
358             new Object[] {
359                 new Long(wikiPageModelImpl.getOriginalNodeId()),
360                 
361             wikiPageModelImpl.getOriginalTitle(),
362                 new Double(wikiPageModelImpl.getOriginalVersion())
363             });
364 
365         EntityCacheUtil.removeResult(WikiPageModelImpl.ENTITY_CACHE_ENABLED,
366             WikiPageImpl.class, wikiPage.getPrimaryKey());
367 
368         return wikiPage;
369     }
370 
371     /**
372      * @deprecated Use {@link BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)}.
373      */
374     public WikiPage update(WikiPage wikiPage) throws SystemException {
375         if (_log.isWarnEnabled()) {
376             _log.warn(
377                 "Using the deprecated update(WikiPage wikiPage) method. Use update(WikiPage wikiPage, boolean merge) instead.");
378         }
379 
380         return update(wikiPage, false);
381     }
382 
383     public WikiPage updateImpl(
384         com.liferay.portlet.wiki.model.WikiPage wikiPage, boolean merge)
385         throws SystemException {
386         wikiPage = toUnwrappedModel(wikiPage);
387 
388         boolean isNew = wikiPage.isNew();
389 
390         WikiPageModelImpl wikiPageModelImpl = (WikiPageModelImpl)wikiPage;
391 
392         if (Validator.isNull(wikiPage.getUuid())) {
393             String uuid = PortalUUIDUtil.generate();
394 
395             wikiPage.setUuid(uuid);
396         }
397 
398         Session session = null;
399 
400         try {
401             session = openSession();
402 
403             BatchSessionUtil.update(session, wikiPage, merge);
404 
405             wikiPage.setNew(false);
406         }
407         catch (Exception e) {
408             throw processException(e);
409         }
410         finally {
411             closeSession(session);
412         }
413 
414         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
415 
416         EntityCacheUtil.putResult(WikiPageModelImpl.ENTITY_CACHE_ENABLED,
417             WikiPageImpl.class, wikiPage.getPrimaryKey(), wikiPage);
418 
419         if (!isNew &&
420                 (!Validator.equals(wikiPage.getUuid(),
421                     wikiPageModelImpl.getOriginalUuid()) ||
422                 (wikiPage.getGroupId() != wikiPageModelImpl.getOriginalGroupId()))) {
423             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
424                 new Object[] {
425                     wikiPageModelImpl.getOriginalUuid(),
426                     new Long(wikiPageModelImpl.getOriginalGroupId())
427                 });
428         }
429 
430         if (isNew ||
431                 (!Validator.equals(wikiPage.getUuid(),
432                     wikiPageModelImpl.getOriginalUuid()) ||
433                 (wikiPage.getGroupId() != wikiPageModelImpl.getOriginalGroupId()))) {
434             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
435                 new Object[] { wikiPage.getUuid(), new Long(
436                         wikiPage.getGroupId()) }, wikiPage);
437         }
438 
439         if (!isNew &&
440                 ((wikiPage.getNodeId() != wikiPageModelImpl.getOriginalNodeId()) ||
441                 !Validator.equals(wikiPage.getTitle(),
442                     wikiPageModelImpl.getOriginalTitle()) ||
443                 (wikiPage.getVersion() != wikiPageModelImpl.getOriginalVersion()))) {
444             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_N_T_V,
445                 new Object[] {
446                     new Long(wikiPageModelImpl.getOriginalNodeId()),
447                     
448                 wikiPageModelImpl.getOriginalTitle(),
449                     new Double(wikiPageModelImpl.getOriginalVersion())
450                 });
451         }
452 
453         if (isNew ||
454                 ((wikiPage.getNodeId() != wikiPageModelImpl.getOriginalNodeId()) ||
455                 !Validator.equals(wikiPage.getTitle(),
456                     wikiPageModelImpl.getOriginalTitle()) ||
457                 (wikiPage.getVersion() != wikiPageModelImpl.getOriginalVersion()))) {
458             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_N_T_V,
459                 new Object[] {
460                     new Long(wikiPage.getNodeId()),
461                     
462                 wikiPage.getTitle(), new Double(wikiPage.getVersion())
463                 }, wikiPage);
464         }
465 
466         return wikiPage;
467     }
468 
469     protected WikiPage toUnwrappedModel(WikiPage wikiPage) {
470         if (wikiPage instanceof WikiPageImpl) {
471             return wikiPage;
472         }
473 
474         WikiPageImpl wikiPageImpl = new WikiPageImpl();
475 
476         wikiPageImpl.setNew(wikiPage.isNew());
477         wikiPageImpl.setPrimaryKey(wikiPage.getPrimaryKey());
478 
479         wikiPageImpl.setUuid(wikiPage.getUuid());
480         wikiPageImpl.setPageId(wikiPage.getPageId());
481         wikiPageImpl.setResourcePrimKey(wikiPage.getResourcePrimKey());
482         wikiPageImpl.setGroupId(wikiPage.getGroupId());
483         wikiPageImpl.setCompanyId(wikiPage.getCompanyId());
484         wikiPageImpl.setUserId(wikiPage.getUserId());
485         wikiPageImpl.setUserName(wikiPage.getUserName());
486         wikiPageImpl.setCreateDate(wikiPage.getCreateDate());
487         wikiPageImpl.setModifiedDate(wikiPage.getModifiedDate());
488         wikiPageImpl.setNodeId(wikiPage.getNodeId());
489         wikiPageImpl.setTitle(wikiPage.getTitle());
490         wikiPageImpl.setVersion(wikiPage.getVersion());
491         wikiPageImpl.setMinorEdit(wikiPage.isMinorEdit());
492         wikiPageImpl.setContent(wikiPage.getContent());
493         wikiPageImpl.setSummary(wikiPage.getSummary());
494         wikiPageImpl.setFormat(wikiPage.getFormat());
495         wikiPageImpl.setHead(wikiPage.isHead());
496         wikiPageImpl.setParentTitle(wikiPage.getParentTitle());
497         wikiPageImpl.setRedirectTitle(wikiPage.getRedirectTitle());
498 
499         return wikiPageImpl;
500     }
501 
502     public WikiPage findByPrimaryKey(Serializable primaryKey)
503         throws NoSuchModelException, SystemException {
504         return findByPrimaryKey(((Long)primaryKey).longValue());
505     }
506 
507     public WikiPage findByPrimaryKey(long pageId)
508         throws NoSuchPageException, SystemException {
509         WikiPage wikiPage = fetchByPrimaryKey(pageId);
510 
511         if (wikiPage == null) {
512             if (_log.isWarnEnabled()) {
513                 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + pageId);
514             }
515 
516             throw new NoSuchPageException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
517                 pageId);
518         }
519 
520         return wikiPage;
521     }
522 
523     public WikiPage fetchByPrimaryKey(Serializable primaryKey)
524         throws SystemException {
525         return fetchByPrimaryKey(((Long)primaryKey).longValue());
526     }
527 
528     public WikiPage fetchByPrimaryKey(long pageId) throws SystemException {
529         WikiPage wikiPage = (WikiPage)EntityCacheUtil.getResult(WikiPageModelImpl.ENTITY_CACHE_ENABLED,
530                 WikiPageImpl.class, pageId, this);
531 
532         if (wikiPage == null) {
533             Session session = null;
534 
535             try {
536                 session = openSession();
537 
538                 wikiPage = (WikiPage)session.get(WikiPageImpl.class,
539                         new Long(pageId));
540             }
541             catch (Exception e) {
542                 throw processException(e);
543             }
544             finally {
545                 if (wikiPage != null) {
546                     cacheResult(wikiPage);
547                 }
548 
549                 closeSession(session);
550             }
551         }
552 
553         return wikiPage;
554     }
555 
556     public List<WikiPage> findByUuid(String uuid) throws SystemException {
557         return findByUuid(uuid, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
558     }
559 
560     public List<WikiPage> findByUuid(String uuid, int start, int end)
561         throws SystemException {
562         return findByUuid(uuid, start, end, null);
563     }
564 
565     public List<WikiPage> findByUuid(String uuid, int start, int end,
566         OrderByComparator orderByComparator) throws SystemException {
567         Object[] finderArgs = new Object[] {
568                 uuid,
569                 
570                 String.valueOf(start), String.valueOf(end),
571                 String.valueOf(orderByComparator)
572             };
573 
574         List<WikiPage> list = (List<WikiPage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_UUID,
575                 finderArgs, this);
576 
577         if (list == null) {
578             StringBundler query = null;
579 
580             if (orderByComparator != null) {
581                 query = new StringBundler(3 +
582                         (orderByComparator.getOrderByFields().length * 3));
583             }
584             else {
585                 query = new StringBundler(3);
586             }
587 
588             query.append(_SQL_SELECT_WIKIPAGE_WHERE);
589 
590             if (uuid == null) {
591                 query.append(_FINDER_COLUMN_UUID_UUID_1);
592             }
593             else {
594                 if (uuid.equals(StringPool.BLANK)) {
595                     query.append(_FINDER_COLUMN_UUID_UUID_3);
596                 }
597                 else {
598                     query.append(_FINDER_COLUMN_UUID_UUID_2);
599                 }
600             }
601 
602             if (orderByComparator != null) {
603                 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
604                     orderByComparator);
605             }
606 
607             else {
608                 query.append(WikiPageModelImpl.ORDER_BY_JPQL);
609             }
610 
611             String sql = query.toString();
612 
613             Session session = null;
614 
615             try {
616                 session = openSession();
617 
618                 Query q = session.createQuery(sql);
619 
620                 QueryPos qPos = QueryPos.getInstance(q);
621 
622                 if (uuid != null) {
623                     qPos.add(uuid);
624                 }
625 
626                 list = (List<WikiPage>)QueryUtil.list(q, getDialect(), start,
627                         end);
628             }
629             catch (Exception e) {
630                 throw processException(e);
631             }
632             finally {
633                 if (list == null) {
634                     list = new ArrayList<WikiPage>();
635                 }
636 
637                 cacheResult(list);
638 
639                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_UUID, finderArgs,
640                     list);
641 
642                 closeSession(session);
643             }
644         }
645 
646         return list;
647     }
648 
649     public WikiPage findByUuid_First(String uuid,
650         OrderByComparator orderByComparator)
651         throws NoSuchPageException, SystemException {
652         List<WikiPage> list = findByUuid(uuid, 0, 1, orderByComparator);
653 
654         if (list.isEmpty()) {
655             StringBundler msg = new StringBundler(4);
656 
657             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
658 
659             msg.append("uuid=");
660             msg.append(uuid);
661 
662             msg.append(StringPool.CLOSE_CURLY_BRACE);
663 
664             throw new NoSuchPageException(msg.toString());
665         }
666         else {
667             return list.get(0);
668         }
669     }
670 
671     public WikiPage findByUuid_Last(String uuid,
672         OrderByComparator orderByComparator)
673         throws NoSuchPageException, SystemException {
674         int count = countByUuid(uuid);
675 
676         List<WikiPage> list = findByUuid(uuid, count - 1, count,
677                 orderByComparator);
678 
679         if (list.isEmpty()) {
680             StringBundler msg = new StringBundler(4);
681 
682             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
683 
684             msg.append("uuid=");
685             msg.append(uuid);
686 
687             msg.append(StringPool.CLOSE_CURLY_BRACE);
688 
689             throw new NoSuchPageException(msg.toString());
690         }
691         else {
692             return list.get(0);
693         }
694     }
695 
696     public WikiPage[] findByUuid_PrevAndNext(long pageId, String uuid,
697         OrderByComparator orderByComparator)
698         throws NoSuchPageException, SystemException {
699         WikiPage wikiPage = findByPrimaryKey(pageId);
700 
701         Session session = null;
702 
703         try {
704             session = openSession();
705 
706             WikiPage[] array = new WikiPageImpl[3];
707 
708             array[0] = getByUuid_PrevAndNext(session, wikiPage, uuid,
709                     orderByComparator, true);
710 
711             array[1] = wikiPage;
712 
713             array[2] = getByUuid_PrevAndNext(session, wikiPage, uuid,
714                     orderByComparator, false);
715 
716             return array;
717         }
718         catch (Exception e) {
719             throw processException(e);
720         }
721         finally {
722             closeSession(session);
723         }
724     }
725 
726     protected WikiPage getByUuid_PrevAndNext(Session session,
727         WikiPage wikiPage, String uuid, OrderByComparator orderByComparator,
728         boolean previous) {
729         StringBundler query = null;
730 
731         if (orderByComparator != null) {
732             query = new StringBundler(6 +
733                     (orderByComparator.getOrderByFields().length * 6));
734         }
735         else {
736             query = new StringBundler(3);
737         }
738 
739         query.append(_SQL_SELECT_WIKIPAGE_WHERE);
740 
741         if (uuid == null) {
742             query.append(_FINDER_COLUMN_UUID_UUID_1);
743         }
744         else {
745             if (uuid.equals(StringPool.BLANK)) {
746                 query.append(_FINDER_COLUMN_UUID_UUID_3);
747             }
748             else {
749                 query.append(_FINDER_COLUMN_UUID_UUID_2);
750             }
751         }
752 
753         if (orderByComparator != null) {
754             String[] orderByFields = orderByComparator.getOrderByFields();
755 
756             if (orderByFields.length > 0) {
757                 query.append(WHERE_AND);
758             }
759 
760             for (int i = 0; i < orderByFields.length; i++) {
761                 query.append(_ORDER_BY_ENTITY_ALIAS);
762                 query.append(orderByFields[i]);
763 
764                 if ((i + 1) < orderByFields.length) {
765                     if (orderByComparator.isAscending() ^ previous) {
766                         query.append(WHERE_GREATER_THAN_HAS_NEXT);
767                     }
768                     else {
769                         query.append(WHERE_LESSER_THAN_HAS_NEXT);
770                     }
771                 }
772                 else {
773                     if (orderByComparator.isAscending() ^ previous) {
774                         query.append(WHERE_GREATER_THAN);
775                     }
776                     else {
777                         query.append(WHERE_LESSER_THAN);
778                     }
779                 }
780             }
781 
782             query.append(ORDER_BY_CLAUSE);
783 
784             for (int i = 0; i < orderByFields.length; i++) {
785                 query.append(_ORDER_BY_ENTITY_ALIAS);
786                 query.append(orderByFields[i]);
787 
788                 if ((i + 1) < orderByFields.length) {
789                     if (orderByComparator.isAscending() ^ previous) {
790                         query.append(ORDER_BY_ASC_HAS_NEXT);
791                     }
792                     else {
793                         query.append(ORDER_BY_DESC_HAS_NEXT);
794                     }
795                 }
796                 else {
797                     if (orderByComparator.isAscending() ^ previous) {
798                         query.append(ORDER_BY_ASC);
799                     }
800                     else {
801                         query.append(ORDER_BY_DESC);
802                     }
803                 }
804             }
805         }
806 
807         else {
808             query.append(WikiPageModelImpl.ORDER_BY_JPQL);
809         }
810 
811         String sql = query.toString();
812 
813         Query q = session.createQuery(sql);
814 
815         q.setFirstResult(0);
816         q.setMaxResults(2);
817 
818         QueryPos qPos = QueryPos.getInstance(q);
819 
820         if (uuid != null) {
821             qPos.add(uuid);
822         }
823 
824         if (orderByComparator != null) {
825             Object[] values = orderByComparator.getOrderByValues(wikiPage);
826 
827             for (Object value : values) {
828                 qPos.add(value);
829             }
830         }
831 
832         List<WikiPage> list = q.list();
833 
834         if (list.size() == 2) {
835             return list.get(1);
836         }
837         else {
838             return null;
839         }
840     }
841 
842     public WikiPage findByUUID_G(String uuid, long groupId)
843         throws NoSuchPageException, SystemException {
844         WikiPage wikiPage = fetchByUUID_G(uuid, groupId);
845 
846         if (wikiPage == null) {
847             StringBundler msg = new StringBundler(6);
848 
849             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
850 
851             msg.append("uuid=");
852             msg.append(uuid);
853 
854             msg.append(", groupId=");
855             msg.append(groupId);
856 
857             msg.append(StringPool.CLOSE_CURLY_BRACE);
858 
859             if (_log.isWarnEnabled()) {
860                 _log.warn(msg.toString());
861             }
862 
863             throw new NoSuchPageException(msg.toString());
864         }
865 
866         return wikiPage;
867     }
868 
869     public WikiPage fetchByUUID_G(String uuid, long groupId)
870         throws SystemException {
871         return fetchByUUID_G(uuid, groupId, true);
872     }
873 
874     public WikiPage fetchByUUID_G(String uuid, long groupId,
875         boolean retrieveFromCache) throws SystemException {
876         Object[] finderArgs = new Object[] { uuid, groupId };
877 
878         Object result = null;
879 
880         if (retrieveFromCache) {
881             result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_UUID_G,
882                     finderArgs, this);
883         }
884 
885         if (result == null) {
886             StringBundler query = new StringBundler(4);
887 
888             query.append(_SQL_SELECT_WIKIPAGE_WHERE);
889 
890             if (uuid == null) {
891                 query.append(_FINDER_COLUMN_UUID_G_UUID_1);
892             }
893             else {
894                 if (uuid.equals(StringPool.BLANK)) {
895                     query.append(_FINDER_COLUMN_UUID_G_UUID_3);
896                 }
897                 else {
898                     query.append(_FINDER_COLUMN_UUID_G_UUID_2);
899                 }
900             }
901 
902             query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
903 
904             query.append(WikiPageModelImpl.ORDER_BY_JPQL);
905 
906             String sql = query.toString();
907 
908             Session session = null;
909 
910             try {
911                 session = openSession();
912 
913                 Query q = session.createQuery(sql);
914 
915                 QueryPos qPos = QueryPos.getInstance(q);
916 
917                 if (uuid != null) {
918                     qPos.add(uuid);
919                 }
920 
921                 qPos.add(groupId);
922 
923                 List<WikiPage> list = q.list();
924 
925                 result = list;
926 
927                 WikiPage wikiPage = null;
928 
929                 if (list.isEmpty()) {
930                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
931                         finderArgs, list);
932                 }
933                 else {
934                     wikiPage = list.get(0);
935 
936                     cacheResult(wikiPage);
937 
938                     if ((wikiPage.getUuid() == null) ||
939                             !wikiPage.getUuid().equals(uuid) ||
940                             (wikiPage.getGroupId() != groupId)) {
941                         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
942                             finderArgs, wikiPage);
943                     }
944                 }
945 
946                 return wikiPage;
947             }
948             catch (Exception e) {
949                 throw processException(e);
950             }
951             finally {
952                 if (result == null) {
953                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
954                         finderArgs, new ArrayList<WikiPage>());
955                 }
956 
957                 closeSession(session);
958             }
959         }
960         else {
961             if (result instanceof List<?>) {
962                 return null;
963             }
964             else {
965                 return (WikiPage)result;
966             }
967         }
968     }
969 
970     public List<WikiPage> findByNodeId(long nodeId) throws SystemException {
971         return findByNodeId(nodeId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
972     }
973 
974     public List<WikiPage> findByNodeId(long nodeId, int start, int end)
975         throws SystemException {
976         return findByNodeId(nodeId, start, end, null);
977     }
978 
979     public List<WikiPage> findByNodeId(long nodeId, int start, int end,
980         OrderByComparator orderByComparator) throws SystemException {
981         Object[] finderArgs = new Object[] {
982                 nodeId,
983                 
984                 String.valueOf(start), String.valueOf(end),
985                 String.valueOf(orderByComparator)
986             };
987 
988         List<WikiPage> list = (List<WikiPage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_NODEID,
989                 finderArgs, this);
990 
991         if (list == null) {
992             StringBundler query = null;
993 
994             if (orderByComparator != null) {
995                 query = new StringBundler(3 +
996                         (orderByComparator.getOrderByFields().length * 3));
997             }
998             else {
999                 query = new StringBundler(3);
1000            }
1001
1002            query.append(_SQL_SELECT_WIKIPAGE_WHERE);
1003
1004            query.append(_FINDER_COLUMN_NODEID_NODEID_2);
1005
1006            if (orderByComparator != null) {
1007                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1008                    orderByComparator);
1009            }
1010
1011            else {
1012                query.append(WikiPageModelImpl.ORDER_BY_JPQL);
1013            }
1014
1015            String sql = query.toString();
1016
1017            Session session = null;
1018
1019            try {
1020                session = openSession();
1021
1022                Query q = session.createQuery(sql);
1023
1024                QueryPos qPos = QueryPos.getInstance(q);
1025
1026                qPos.add(nodeId);
1027
1028                list = (List<WikiPage>)QueryUtil.list(q, getDialect(), start,
1029                        end);
1030            }
1031            catch (Exception e) {
1032                throw processException(e);
1033            }
1034            finally {
1035                if (list == null) {
1036                    list = new ArrayList<WikiPage>();
1037                }
1038
1039                cacheResult(list);
1040
1041                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_NODEID,
1042                    finderArgs, list);
1043
1044                closeSession(session);
1045            }
1046        }
1047
1048        return list;
1049    }
1050
1051    public WikiPage findByNodeId_First(long nodeId,
1052        OrderByComparator orderByComparator)
1053        throws NoSuchPageException, SystemException {
1054        List<WikiPage> list = findByNodeId(nodeId, 0, 1, orderByComparator);
1055
1056        if (list.isEmpty()) {
1057            StringBundler msg = new StringBundler(4);
1058
1059            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1060
1061            msg.append("nodeId=");
1062            msg.append(nodeId);
1063
1064            msg.append(StringPool.CLOSE_CURLY_BRACE);
1065
1066            throw new NoSuchPageException(msg.toString());
1067        }
1068        else {
1069            return list.get(0);
1070        }
1071    }
1072
1073    public WikiPage findByNodeId_Last(long nodeId,
1074        OrderByComparator orderByComparator)
1075        throws NoSuchPageException, SystemException {
1076        int count = countByNodeId(nodeId);
1077
1078        List<WikiPage> list = findByNodeId(nodeId, count - 1, count,
1079                orderByComparator);
1080
1081        if (list.isEmpty()) {
1082            StringBundler msg = new StringBundler(4);
1083
1084            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1085
1086            msg.append("nodeId=");
1087            msg.append(nodeId);
1088
1089            msg.append(StringPool.CLOSE_CURLY_BRACE);
1090
1091            throw new NoSuchPageException(msg.toString());
1092        }
1093        else {
1094            return list.get(0);
1095        }
1096    }
1097
1098    public WikiPage[] findByNodeId_PrevAndNext(long pageId, long nodeId,
1099        OrderByComparator orderByComparator)
1100        throws NoSuchPageException, SystemException {
1101        WikiPage wikiPage = findByPrimaryKey(pageId);
1102
1103        Session session = null;
1104
1105        try {
1106            session = openSession();
1107
1108            WikiPage[] array = new WikiPageImpl[3];
1109
1110            array[0] = getByNodeId_PrevAndNext(session, wikiPage, nodeId,
1111                    orderByComparator, true);
1112
1113            array[1] = wikiPage;
1114
1115            array[2] = getByNodeId_PrevAndNext(session, wikiPage, nodeId,
1116                    orderByComparator, false);
1117
1118            return array;
1119        }
1120        catch (Exception e) {
1121            throw processException(e);
1122        }
1123        finally {
1124            closeSession(session);
1125        }
1126    }
1127
1128    protected WikiPage getByNodeId_PrevAndNext(Session session,
1129        WikiPage wikiPage, long nodeId, OrderByComparator orderByComparator,
1130        boolean previous) {
1131        StringBundler query = null;
1132
1133        if (orderByComparator != null) {
1134            query = new StringBundler(6 +
1135                    (orderByComparator.getOrderByFields().length * 6));
1136        }
1137        else {
1138            query = new StringBundler(3);
1139        }
1140
1141        query.append(_SQL_SELECT_WIKIPAGE_WHERE);
1142
1143        query.append(_FINDER_COLUMN_NODEID_NODEID_2);
1144
1145        if (orderByComparator != null) {
1146            String[] orderByFields = orderByComparator.getOrderByFields();
1147
1148            if (orderByFields.length > 0) {
1149                query.append(WHERE_AND);
1150            }
1151
1152            for (int i = 0; i < orderByFields.length; i++) {
1153                query.append(_ORDER_BY_ENTITY_ALIAS);
1154                query.append(orderByFields[i]);
1155
1156                if ((i + 1) < orderByFields.length) {
1157                    if (orderByComparator.isAscending() ^ previous) {
1158                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
1159                    }
1160                    else {
1161                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
1162                    }
1163                }
1164                else {
1165                    if (orderByComparator.isAscending() ^ previous) {
1166                        query.append(WHERE_GREATER_THAN);
1167                    }
1168                    else {
1169                        query.append(WHERE_LESSER_THAN);
1170                    }
1171                }
1172            }
1173
1174            query.append(ORDER_BY_CLAUSE);
1175
1176            for (int i = 0; i < orderByFields.length; i++) {
1177                query.append(_ORDER_BY_ENTITY_ALIAS);
1178                query.append(orderByFields[i]);
1179
1180                if ((i + 1) < orderByFields.length) {
1181                    if (orderByComparator.isAscending() ^ previous) {
1182                        query.append(ORDER_BY_ASC_HAS_NEXT);
1183                    }
1184                    else {
1185                        query.append(ORDER_BY_DESC_HAS_NEXT);
1186                    }
1187                }
1188                else {
1189                    if (orderByComparator.isAscending() ^ previous) {
1190                        query.append(ORDER_BY_ASC);
1191                    }
1192                    else {
1193                        query.append(ORDER_BY_DESC);
1194                    }
1195                }
1196            }
1197        }
1198
1199        else {
1200            query.append(WikiPageModelImpl.ORDER_BY_JPQL);
1201        }
1202
1203        String sql = query.toString();
1204
1205        Query q = session.createQuery(sql);
1206
1207        q.setFirstResult(0);
1208        q.setMaxResults(2);
1209
1210        QueryPos qPos = QueryPos.getInstance(q);
1211
1212        qPos.add(nodeId);
1213
1214        if (orderByComparator != null) {
1215            Object[] values = orderByComparator.getOrderByValues(wikiPage);
1216
1217            for (Object value : values) {
1218                qPos.add(value);
1219            }
1220        }
1221
1222        List<WikiPage> list = q.list();
1223
1224        if (list.size() == 2) {
1225            return list.get(1);
1226        }
1227        else {
1228            return null;
1229        }
1230    }
1231
1232    public List<WikiPage> findByFormat(String format) throws SystemException {
1233        return findByFormat(format, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1234    }
1235
1236    public List<WikiPage> findByFormat(String format, int start, int end)
1237        throws SystemException {
1238        return findByFormat(format, start, end, null);
1239    }
1240
1241    public List<WikiPage> findByFormat(String format, int start, int end,
1242        OrderByComparator orderByComparator) throws SystemException {
1243        Object[] finderArgs = new Object[] {
1244                format,
1245                
1246                String.valueOf(start), String.valueOf(end),
1247                String.valueOf(orderByComparator)
1248            };
1249
1250        List<WikiPage> list = (List<WikiPage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_FORMAT,
1251                finderArgs, this);
1252
1253        if (list == null) {
1254            StringBundler query = null;
1255
1256            if (orderByComparator != null) {
1257                query = new StringBundler(3 +
1258                        (orderByComparator.getOrderByFields().length * 3));
1259            }
1260            else {
1261                query = new StringBundler(3);
1262            }
1263
1264            query.append(_SQL_SELECT_WIKIPAGE_WHERE);
1265
1266            if (format == null) {
1267                query.append(_FINDER_COLUMN_FORMAT_FORMAT_1);
1268            }
1269            else {
1270                if (format.equals(StringPool.BLANK)) {
1271                    query.append(_FINDER_COLUMN_FORMAT_FORMAT_3);
1272                }
1273                else {
1274                    query.append(_FINDER_COLUMN_FORMAT_FORMAT_2);
1275                }
1276            }
1277
1278            if (orderByComparator != null) {
1279                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1280                    orderByComparator);
1281            }
1282
1283            else {
1284                query.append(WikiPageModelImpl.ORDER_BY_JPQL);
1285            }
1286
1287            String sql = query.toString();
1288
1289            Session session = null;
1290
1291            try {
1292                session = openSession();
1293
1294                Query q = session.createQuery(sql);
1295
1296                QueryPos qPos = QueryPos.getInstance(q);
1297
1298                if (format != null) {
1299                    qPos.add(format);
1300                }
1301
1302                list = (List<WikiPage>)QueryUtil.list(q, getDialect(), start,
1303                        end);
1304            }
1305            catch (Exception e) {
1306                throw processException(e);
1307            }
1308            finally {
1309                if (list == null) {
1310                    list = new ArrayList<WikiPage>();
1311                }
1312
1313                cacheResult(list);
1314
1315                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_FORMAT,
1316                    finderArgs, list);
1317
1318                closeSession(session);
1319            }
1320        }
1321
1322        return list;
1323    }
1324
1325    public WikiPage findByFormat_First(String format,
1326        OrderByComparator orderByComparator)
1327        throws NoSuchPageException, SystemException {
1328        List<WikiPage> list = findByFormat(format, 0, 1, orderByComparator);
1329
1330        if (list.isEmpty()) {
1331            StringBundler msg = new StringBundler(4);
1332
1333            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1334
1335            msg.append("format=");
1336            msg.append(format);
1337
1338            msg.append(StringPool.CLOSE_CURLY_BRACE);
1339
1340            throw new NoSuchPageException(msg.toString());
1341        }
1342        else {
1343            return list.get(0);
1344        }
1345    }
1346
1347    public WikiPage findByFormat_Last(String format,
1348        OrderByComparator orderByComparator)
1349        throws NoSuchPageException, SystemException {
1350        int count = countByFormat(format);
1351
1352        List<WikiPage> list = findByFormat(format, count - 1, count,
1353                orderByComparator);
1354
1355        if (list.isEmpty()) {
1356            StringBundler msg = new StringBundler(4);
1357
1358            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1359
1360            msg.append("format=");
1361            msg.append(format);
1362
1363            msg.append(StringPool.CLOSE_CURLY_BRACE);
1364
1365            throw new NoSuchPageException(msg.toString());
1366        }
1367        else {
1368            return list.get(0);
1369        }
1370    }
1371
1372    public WikiPage[] findByFormat_PrevAndNext(long pageId, String format,
1373        OrderByComparator orderByComparator)
1374        throws NoSuchPageException, SystemException {
1375        WikiPage wikiPage = findByPrimaryKey(pageId);
1376
1377        Session session = null;
1378
1379        try {
1380            session = openSession();
1381
1382            WikiPage[] array = new WikiPageImpl[3];
1383
1384            array[0] = getByFormat_PrevAndNext(session, wikiPage, format,
1385                    orderByComparator, true);
1386
1387            array[1] = wikiPage;
1388
1389            array[2] = getByFormat_PrevAndNext(session, wikiPage, format,
1390                    orderByComparator, false);
1391
1392            return array;
1393        }
1394        catch (Exception e) {
1395            throw processException(e);
1396        }
1397        finally {
1398            closeSession(session);
1399        }
1400    }
1401
1402    protected WikiPage getByFormat_PrevAndNext(Session session,
1403        WikiPage wikiPage, String format, OrderByComparator orderByComparator,
1404        boolean previous) {
1405        StringBundler query = null;
1406
1407        if (orderByComparator != null) {
1408            query = new StringBundler(6 +
1409                    (orderByComparator.getOrderByFields().length * 6));
1410        }
1411        else {
1412            query = new StringBundler(3);
1413        }
1414
1415        query.append(_SQL_SELECT_WIKIPAGE_WHERE);
1416
1417        if (format == null) {
1418            query.append(_FINDER_COLUMN_FORMAT_FORMAT_1);
1419        }
1420        else {
1421            if (format.equals(StringPool.BLANK)) {
1422                query.append(_FINDER_COLUMN_FORMAT_FORMAT_3);
1423            }
1424            else {
1425                query.append(_FINDER_COLUMN_FORMAT_FORMAT_2);
1426            }
1427        }
1428
1429        if (orderByComparator != null) {
1430            String[] orderByFields = orderByComparator.getOrderByFields();
1431
1432            if (orderByFields.length > 0) {
1433                query.append(WHERE_AND);
1434            }
1435
1436            for (int i = 0; i < orderByFields.length; i++) {
1437                query.append(_ORDER_BY_ENTITY_ALIAS);
1438                query.append(orderByFields[i]);
1439
1440                if ((i + 1) < orderByFields.length) {
1441                    if (orderByComparator.isAscending() ^ previous) {
1442                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
1443                    }
1444                    else {
1445                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
1446                    }
1447                }
1448                else {
1449                    if (orderByComparator.isAscending() ^ previous) {
1450                        query.append(WHERE_GREATER_THAN);
1451                    }
1452                    else {
1453                        query.append(WHERE_LESSER_THAN);
1454                    }
1455                }
1456            }
1457
1458            query.append(ORDER_BY_CLAUSE);
1459
1460            for (int i = 0; i < orderByFields.length; i++) {
1461                query.append(_ORDER_BY_ENTITY_ALIAS);
1462                query.append(orderByFields[i]);
1463
1464                if ((i + 1) < orderByFields.length) {
1465                    if (orderByComparator.isAscending() ^ previous) {
1466                        query.append(ORDER_BY_ASC_HAS_NEXT);
1467                    }
1468                    else {
1469                        query.append(ORDER_BY_DESC_HAS_NEXT);
1470                    }
1471                }
1472                else {
1473                    if (orderByComparator.isAscending() ^ previous) {
1474                        query.append(ORDER_BY_ASC);
1475                    }
1476                    else {
1477                        query.append(ORDER_BY_DESC);
1478                    }
1479                }
1480            }
1481        }
1482
1483        else {
1484            query.append(WikiPageModelImpl.ORDER_BY_JPQL);
1485        }
1486
1487        String sql = query.toString();
1488
1489        Query q = session.createQuery(sql);
1490
1491        q.setFirstResult(0);
1492        q.setMaxResults(2);
1493
1494        QueryPos qPos = QueryPos.getInstance(q);
1495
1496        if (format != null) {
1497            qPos.add(format);
1498        }
1499
1500        if (orderByComparator != null) {
1501            Object[] values = orderByComparator.getOrderByValues(wikiPage);
1502
1503            for (Object value : values) {
1504                qPos.add(value);
1505            }
1506        }
1507
1508        List<WikiPage> list = q.list();
1509
1510        if (list.size() == 2) {
1511            return list.get(1);
1512        }
1513        else {
1514            return null;
1515        }
1516    }
1517
1518    public List<WikiPage> findByN_T(long nodeId, String title)
1519        throws SystemException {
1520        return findByN_T(nodeId, title, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
1521            null);
1522    }
1523
1524    public List<WikiPage> findByN_T(long nodeId, String title, int start,
1525        int end) throws SystemException {
1526        return findByN_T(nodeId, title, start, end, null);
1527    }
1528
1529    public List<WikiPage> findByN_T(long nodeId, String title, int start,
1530        int end, OrderByComparator orderByComparator) throws SystemException {
1531        Object[] finderArgs = new Object[] {
1532                nodeId, title,
1533                
1534                String.valueOf(start), String.valueOf(end),
1535                String.valueOf(orderByComparator)
1536            };
1537
1538        List<WikiPage> list = (List<WikiPage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_N_T,
1539                finderArgs, this);
1540
1541        if (list == null) {
1542            StringBundler query = null;
1543
1544            if (orderByComparator != null) {
1545                query = new StringBundler(4 +
1546                        (orderByComparator.getOrderByFields().length * 3));
1547            }
1548            else {
1549                query = new StringBundler(4);
1550            }
1551
1552            query.append(_SQL_SELECT_WIKIPAGE_WHERE);
1553
1554            query.append(_FINDER_COLUMN_N_T_NODEID_2);
1555
1556            if (title == null) {
1557                query.append(_FINDER_COLUMN_N_T_TITLE_1);
1558            }
1559            else {
1560                if (title.equals(StringPool.BLANK)) {
1561                    query.append(_FINDER_COLUMN_N_T_TITLE_3);
1562                }
1563                else {
1564                    query.append(_FINDER_COLUMN_N_T_TITLE_2);
1565                }
1566            }
1567
1568            if (orderByComparator != null) {
1569                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1570                    orderByComparator);
1571            }
1572
1573            else {
1574                query.append(WikiPageModelImpl.ORDER_BY_JPQL);
1575            }
1576
1577            String sql = query.toString();
1578
1579            Session session = null;
1580
1581            try {
1582                session = openSession();
1583
1584                Query q = session.createQuery(sql);
1585
1586                QueryPos qPos = QueryPos.getInstance(q);
1587
1588                qPos.add(nodeId);
1589
1590                if (title != null) {
1591                    qPos.add(title);
1592                }
1593
1594                list = (List<WikiPage>)QueryUtil.list(q, getDialect(), start,
1595                        end);
1596            }
1597            catch (Exception e) {
1598                throw processException(e);
1599            }
1600            finally {
1601                if (list == null) {
1602                    list = new ArrayList<WikiPage>();
1603                }
1604
1605                cacheResult(list);
1606
1607                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_N_T, finderArgs,
1608                    list);
1609
1610                closeSession(session);
1611            }
1612        }
1613
1614        return list;
1615    }
1616
1617    public WikiPage findByN_T_First(long nodeId, String title,
1618        OrderByComparator orderByComparator)
1619        throws NoSuchPageException, SystemException {
1620        List<WikiPage> list = findByN_T(nodeId, title, 0, 1, orderByComparator);
1621
1622        if (list.isEmpty()) {
1623            StringBundler msg = new StringBundler(6);
1624
1625            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1626
1627            msg.append("nodeId=");
1628            msg.append(nodeId);
1629
1630            msg.append(", title=");
1631            msg.append(title);
1632
1633            msg.append(StringPool.CLOSE_CURLY_BRACE);
1634
1635            throw new NoSuchPageException(msg.toString());
1636        }
1637        else {
1638            return list.get(0);
1639        }
1640    }
1641
1642    public WikiPage findByN_T_Last(long nodeId, String title,
1643        OrderByComparator orderByComparator)
1644        throws NoSuchPageException, SystemException {
1645        int count = countByN_T(nodeId, title);
1646
1647        List<WikiPage> list = findByN_T(nodeId, title, count - 1, count,
1648                orderByComparator);
1649
1650        if (list.isEmpty()) {
1651            StringBundler msg = new StringBundler(6);
1652
1653            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1654
1655            msg.append("nodeId=");
1656            msg.append(nodeId);
1657
1658            msg.append(", title=");
1659            msg.append(title);
1660
1661            msg.append(StringPool.CLOSE_CURLY_BRACE);
1662
1663            throw new NoSuchPageException(msg.toString());
1664        }
1665        else {
1666            return list.get(0);
1667        }
1668    }
1669
1670    public WikiPage[] findByN_T_PrevAndNext(long pageId, long nodeId,
1671        String title, OrderByComparator orderByComparator)
1672        throws NoSuchPageException, SystemException {
1673        WikiPage wikiPage = findByPrimaryKey(pageId);
1674
1675        Session session = null;
1676
1677        try {
1678            session = openSession();
1679
1680            WikiPage[] array = new WikiPageImpl[3];
1681
1682            array[0] = getByN_T_PrevAndNext(session, wikiPage, nodeId, title,
1683                    orderByComparator, true);
1684
1685            array[1] = wikiPage;
1686
1687            array[2] = getByN_T_PrevAndNext(session, wikiPage, nodeId, title,
1688                    orderByComparator, false);
1689
1690            return array;
1691        }
1692        catch (Exception e) {
1693            throw processException(e);
1694        }
1695        finally {
1696            closeSession(session);
1697        }
1698    }
1699
1700    protected WikiPage getByN_T_PrevAndNext(Session session, WikiPage wikiPage,
1701        long nodeId, String title, OrderByComparator orderByComparator,
1702        boolean previous) {
1703        StringBundler query = null;
1704
1705        if (orderByComparator != null) {
1706            query = new StringBundler(6 +
1707                    (orderByComparator.getOrderByFields().length * 6));
1708        }
1709        else {
1710            query = new StringBundler(3);
1711        }
1712
1713        query.append(_SQL_SELECT_WIKIPAGE_WHERE);
1714
1715        query.append(_FINDER_COLUMN_N_T_NODEID_2);
1716
1717        if (title == null) {
1718            query.append(_FINDER_COLUMN_N_T_TITLE_1);
1719        }
1720        else {
1721            if (title.equals(StringPool.BLANK)) {
1722                query.append(_FINDER_COLUMN_N_T_TITLE_3);
1723            }
1724            else {
1725                query.append(_FINDER_COLUMN_N_T_TITLE_2);
1726            }
1727        }
1728
1729        if (orderByComparator != null) {
1730            String[] orderByFields = orderByComparator.getOrderByFields();
1731
1732            if (orderByFields.length > 0) {
1733                query.append(WHERE_AND);
1734            }
1735
1736            for (int i = 0; i < orderByFields.length; i++) {
1737                query.append(_ORDER_BY_ENTITY_ALIAS);
1738                query.append(orderByFields[i]);
1739
1740                if ((i + 1) < orderByFields.length) {
1741                    if (orderByComparator.isAscending() ^ previous) {
1742                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
1743                    }
1744                    else {
1745                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
1746                    }
1747                }
1748                else {
1749                    if (orderByComparator.isAscending() ^ previous) {
1750                        query.append(WHERE_GREATER_THAN);
1751                    }
1752                    else {
1753                        query.append(WHERE_LESSER_THAN);
1754                    }
1755                }
1756            }
1757
1758            query.append(ORDER_BY_CLAUSE);
1759
1760            for (int i = 0; i < orderByFields.length; i++) {
1761                query.append(_ORDER_BY_ENTITY_ALIAS);
1762                query.append(orderByFields[i]);
1763
1764                if ((i + 1) < orderByFields.length) {
1765                    if (orderByComparator.isAscending() ^ previous) {
1766                        query.append(ORDER_BY_ASC_HAS_NEXT);
1767                    }
1768                    else {
1769                        query.append(ORDER_BY_DESC_HAS_NEXT);
1770                    }
1771                }
1772                else {
1773                    if (orderByComparator.isAscending() ^ previous) {
1774                        query.append(ORDER_BY_ASC);
1775                    }
1776                    else {
1777                        query.append(ORDER_BY_DESC);
1778                    }
1779                }
1780            }
1781        }
1782
1783        else {
1784            query.append(WikiPageModelImpl.ORDER_BY_JPQL);
1785        }
1786
1787        String sql = query.toString();
1788
1789        Query q = session.createQuery(sql);
1790
1791        q.setFirstResult(0);
1792        q.setMaxResults(2);
1793
1794        QueryPos qPos = QueryPos.getInstance(q);
1795
1796        qPos.add(nodeId);
1797
1798        if (title != null) {
1799            qPos.add(title);
1800        }
1801
1802        if (orderByComparator != null) {
1803            Object[] values = orderByComparator.getOrderByValues(wikiPage);
1804
1805            for (Object value : values) {
1806                qPos.add(value);
1807            }
1808        }
1809
1810        List<WikiPage> list = q.list();
1811
1812        if (list.size() == 2) {
1813            return list.get(1);
1814        }
1815        else {
1816            return null;
1817        }
1818    }
1819
1820    public List<WikiPage> findByN_H(long nodeId, boolean head)
1821        throws SystemException {
1822        return findByN_H(nodeId, head, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
1823            null);
1824    }
1825
1826    public List<WikiPage> findByN_H(long nodeId, boolean head, int start,
1827        int end) throws SystemException {
1828        return findByN_H(nodeId, head, start, end, null);
1829    }
1830
1831    public List<WikiPage> findByN_H(long nodeId, boolean head, int start,
1832        int end, OrderByComparator orderByComparator) throws SystemException {
1833        Object[] finderArgs = new Object[] {
1834                nodeId, head,
1835                
1836                String.valueOf(start), String.valueOf(end),
1837                String.valueOf(orderByComparator)
1838            };
1839
1840        List<WikiPage> list = (List<WikiPage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_N_H,
1841                finderArgs, this);
1842
1843        if (list == null) {
1844            StringBundler query = null;
1845
1846            if (orderByComparator != null) {
1847                query = new StringBundler(4 +
1848                        (orderByComparator.getOrderByFields().length * 3));
1849            }
1850            else {
1851                query = new StringBundler(4);
1852            }
1853
1854            query.append(_SQL_SELECT_WIKIPAGE_WHERE);
1855
1856            query.append(_FINDER_COLUMN_N_H_NODEID_2);
1857
1858            query.append(_FINDER_COLUMN_N_H_HEAD_2);
1859
1860            if (orderByComparator != null) {
1861                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1862                    orderByComparator);
1863            }
1864
1865            else {
1866                query.append(WikiPageModelImpl.ORDER_BY_JPQL);
1867            }
1868
1869            String sql = query.toString();
1870
1871            Session session = null;
1872
1873            try {
1874                session = openSession();
1875
1876                Query q = session.createQuery(sql);
1877
1878                QueryPos qPos = QueryPos.getInstance(q);
1879
1880                qPos.add(nodeId);
1881
1882                qPos.add(head);
1883
1884                list = (List<WikiPage>)QueryUtil.list(q, getDialect(), start,
1885                        end);
1886            }
1887            catch (Exception e) {
1888                throw processException(e);
1889            }
1890            finally {
1891                if (list == null) {
1892                    list = new ArrayList<WikiPage>();
1893                }
1894
1895                cacheResult(list);
1896
1897                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_N_H, finderArgs,
1898                    list);
1899
1900                closeSession(session);
1901            }
1902        }
1903
1904        return list;
1905    }
1906
1907    public WikiPage findByN_H_First(long nodeId, boolean head,
1908        OrderByComparator orderByComparator)
1909        throws NoSuchPageException, SystemException {
1910        List<WikiPage> list = findByN_H(nodeId, head, 0, 1, orderByComparator);
1911
1912        if (list.isEmpty()) {
1913            StringBundler msg = new StringBundler(6);
1914
1915            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1916
1917            msg.append("nodeId=");
1918            msg.append(nodeId);
1919
1920            msg.append(", head=");
1921            msg.append(head);
1922
1923            msg.append(StringPool.CLOSE_CURLY_BRACE);
1924
1925            throw new NoSuchPageException(msg.toString());
1926        }
1927        else {
1928            return list.get(0);
1929        }
1930    }
1931
1932    public WikiPage findByN_H_Last(long nodeId, boolean head,
1933        OrderByComparator orderByComparator)
1934        throws NoSuchPageException, SystemException {
1935        int count = countByN_H(nodeId, head);
1936
1937        List<WikiPage> list = findByN_H(nodeId, head, count - 1, count,
1938                orderByComparator);
1939
1940        if (list.isEmpty()) {
1941            StringBundler msg = new StringBundler(6);
1942
1943            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1944
1945            msg.append("nodeId=");
1946            msg.append(nodeId);
1947
1948            msg.append(", head=");
1949            msg.append(head);
1950
1951            msg.append(StringPool.CLOSE_CURLY_BRACE);
1952
1953            throw new NoSuchPageException(msg.toString());
1954        }
1955        else {
1956            return list.get(0);
1957        }
1958    }
1959
1960    public WikiPage[] findByN_H_PrevAndNext(long pageId, long nodeId,
1961        boolean head, OrderByComparator orderByComparator)
1962        throws NoSuchPageException, SystemException {
1963        WikiPage wikiPage = findByPrimaryKey(pageId);
1964
1965        Session session = null;
1966
1967        try {
1968            session = openSession();
1969
1970            WikiPage[] array = new WikiPageImpl[3];
1971
1972            array[0] = getByN_H_PrevAndNext(session, wikiPage, nodeId, head,
1973                    orderByComparator, true);
1974
1975            array[1] = wikiPage;
1976
1977            array[2] = getByN_H_PrevAndNext(session, wikiPage, nodeId, head,
1978                    orderByComparator, false);
1979
1980            return array;
1981        }
1982        catch (Exception e) {
1983            throw processException(e);
1984        }
1985        finally {
1986            closeSession(session);
1987        }
1988    }
1989
1990    protected WikiPage getByN_H_PrevAndNext(Session session, WikiPage wikiPage,
1991        long nodeId, boolean head, OrderByComparator orderByComparator,
1992        boolean previous) {
1993        StringBundler query = null;
1994
1995        if (orderByComparator != null) {
1996            query = new StringBundler(6 +
1997                    (orderByComparator.getOrderByFields().length * 6));
1998        }
1999        else {
2000            query = new StringBundler(3);
2001        }
2002
2003        query.append(_SQL_SELECT_WIKIPAGE_WHERE);
2004
2005        query.append(_FINDER_COLUMN_N_H_NODEID_2);
2006
2007        query.append(_FINDER_COLUMN_N_H_HEAD_2);
2008
2009        if (orderByComparator != null) {
2010            String[] orderByFields = orderByComparator.getOrderByFields();
2011
2012            if (orderByFields.length > 0) {
2013                query.append(WHERE_AND);
2014            }
2015
2016            for (int i = 0; i < orderByFields.length; i++) {
2017                query.append(_ORDER_BY_ENTITY_ALIAS);
2018                query.append(orderByFields[i]);
2019
2020                if ((i + 1) < orderByFields.length) {
2021                    if (orderByComparator.isAscending() ^ previous) {
2022                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
2023                    }
2024                    else {
2025                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
2026                    }
2027                }
2028                else {
2029                    if (orderByComparator.isAscending() ^ previous) {
2030                        query.append(WHERE_GREATER_THAN);
2031                    }
2032                    else {
2033                        query.append(WHERE_LESSER_THAN);
2034                    }
2035                }
2036            }
2037
2038            query.append(ORDER_BY_CLAUSE);
2039
2040            for (int i = 0; i < orderByFields.length; i++) {
2041                query.append(_ORDER_BY_ENTITY_ALIAS);
2042                query.append(orderByFields[i]);
2043
2044                if ((i + 1) < orderByFields.length) {
2045                    if (orderByComparator.isAscending() ^ previous) {
2046                        query.append(ORDER_BY_ASC_HAS_NEXT);
2047                    }
2048                    else {
2049                        query.append(ORDER_BY_DESC_HAS_NEXT);
2050                    }
2051                }
2052                else {
2053                    if (orderByComparator.isAscending() ^ previous) {
2054                        query.append(ORDER_BY_ASC);
2055                    }
2056                    else {
2057                        query.append(ORDER_BY_DESC);
2058                    }
2059                }
2060            }
2061        }
2062
2063        else {
2064            query.append(WikiPageModelImpl.ORDER_BY_JPQL);
2065        }
2066
2067        String sql = query.toString();
2068
2069        Query q = session.createQuery(sql);
2070
2071        q.setFirstResult(0);
2072        q.setMaxResults(2);
2073
2074        QueryPos qPos = QueryPos.getInstance(q);
2075
2076        qPos.add(nodeId);
2077
2078        qPos.add(head);
2079
2080        if (orderByComparator != null) {
2081            Object[] values = orderByComparator.getOrderByValues(wikiPage);
2082
2083            for (Object value : values) {
2084                qPos.add(value);
2085            }
2086        }
2087
2088        List<WikiPage> list = q.list();
2089
2090        if (list.size() == 2) {
2091            return list.get(1);
2092        }
2093        else {
2094            return null;
2095        }
2096    }
2097
2098    public List<WikiPage> findByN_P(long nodeId, String parentTitle)
2099        throws SystemException {
2100        return findByN_P(nodeId, parentTitle, QueryUtil.ALL_POS,
2101            QueryUtil.ALL_POS, null);
2102    }
2103
2104    public List<WikiPage> findByN_P(long nodeId, String parentTitle, int start,
2105        int end) throws SystemException {
2106        return findByN_P(nodeId, parentTitle, start, end, null);
2107    }
2108
2109    public List<WikiPage> findByN_P(long nodeId, String parentTitle, int start,
2110        int end, OrderByComparator orderByComparator) throws SystemException {
2111        Object[] finderArgs = new Object[] {
2112                nodeId, parentTitle,
2113                
2114                String.valueOf(start), String.valueOf(end),
2115                String.valueOf(orderByComparator)
2116            };
2117
2118        List<WikiPage> list = (List<WikiPage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_N_P,
2119                finderArgs, this);
2120
2121        if (list == null) {
2122            StringBundler query = null;
2123
2124            if (orderByComparator != null) {
2125                query = new StringBundler(4 +
2126                        (orderByComparator.getOrderByFields().length * 3));
2127            }
2128            else {
2129                query = new StringBundler(4);
2130            }
2131
2132            query.append(_SQL_SELECT_WIKIPAGE_WHERE);
2133
2134            query.append(_FINDER_COLUMN_N_P_NODEID_2);
2135
2136            if (parentTitle == null) {
2137                query.append(_FINDER_COLUMN_N_P_PARENTTITLE_1);
2138            }
2139            else {
2140                if (parentTitle.equals(StringPool.BLANK)) {
2141                    query.append(_FINDER_COLUMN_N_P_PARENTTITLE_3);
2142                }
2143                else {
2144                    query.append(_FINDER_COLUMN_N_P_PARENTTITLE_2);
2145                }
2146            }
2147
2148            if (orderByComparator != null) {
2149                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2150                    orderByComparator);
2151            }
2152
2153            else {
2154                query.append(WikiPageModelImpl.ORDER_BY_JPQL);
2155            }
2156
2157            String sql = query.toString();
2158
2159            Session session = null;
2160
2161            try {
2162                session = openSession();
2163
2164                Query q = session.createQuery(sql);
2165
2166                QueryPos qPos = QueryPos.getInstance(q);
2167
2168                qPos.add(nodeId);
2169
2170                if (parentTitle != null) {
2171                    qPos.add(parentTitle);
2172                }
2173
2174                list = (List<WikiPage>)QueryUtil.list(q, getDialect(), start,
2175                        end);
2176            }
2177            catch (Exception e) {
2178                throw processException(e);
2179            }
2180            finally {
2181                if (list == null) {
2182                    list = new ArrayList<WikiPage>();
2183                }
2184
2185                cacheResult(list);
2186
2187                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_N_P, finderArgs,
2188                    list);
2189
2190                closeSession(session);
2191            }
2192        }
2193
2194        return list;
2195    }
2196
2197    public WikiPage findByN_P_First(long nodeId, String parentTitle,
2198        OrderByComparator orderByComparator)
2199        throws NoSuchPageException, SystemException {
2200        List<WikiPage> list = findByN_P(nodeId, parentTitle, 0, 1,
2201                orderByComparator);
2202
2203        if (list.isEmpty()) {
2204            StringBundler msg = new StringBundler(6);
2205
2206            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2207
2208            msg.append("nodeId=");
2209            msg.append(nodeId);
2210
2211            msg.append(", parentTitle=");
2212            msg.append(parentTitle);
2213
2214            msg.append(StringPool.CLOSE_CURLY_BRACE);
2215
2216            throw new NoSuchPageException(msg.toString());
2217        }
2218        else {
2219            return list.get(0);
2220        }
2221    }
2222
2223    public WikiPage findByN_P_Last(long nodeId, String parentTitle,
2224        OrderByComparator orderByComparator)
2225        throws NoSuchPageException, SystemException {
2226        int count = countByN_P(nodeId, parentTitle);
2227
2228        List<WikiPage> list = findByN_P(nodeId, parentTitle, count - 1, count,
2229                orderByComparator);
2230
2231        if (list.isEmpty()) {
2232            StringBundler msg = new StringBundler(6);
2233
2234            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2235
2236            msg.append("nodeId=");
2237            msg.append(nodeId);
2238
2239            msg.append(", parentTitle=");
2240            msg.append(parentTitle);
2241
2242            msg.append(StringPool.CLOSE_CURLY_BRACE);
2243
2244            throw new NoSuchPageException(msg.toString());
2245        }
2246        else {
2247            return list.get(0);
2248        }
2249    }
2250
2251    public WikiPage[] findByN_P_PrevAndNext(long pageId, long nodeId,
2252        String parentTitle, OrderByComparator orderByComparator)
2253        throws NoSuchPageException, SystemException {
2254        WikiPage wikiPage = findByPrimaryKey(pageId);
2255
2256        Session session = null;
2257
2258        try {
2259            session = openSession();
2260
2261            WikiPage[] array = new WikiPageImpl[3];
2262
2263            array[0] = getByN_P_PrevAndNext(session, wikiPage, nodeId,
2264                    parentTitle, orderByComparator, true);
2265
2266            array[1] = wikiPage;
2267
2268            array[2] = getByN_P_PrevAndNext(session, wikiPage, nodeId,
2269                    parentTitle, orderByComparator, false);
2270
2271            return array;
2272        }
2273        catch (Exception e) {
2274            throw processException(e);
2275        }
2276        finally {
2277            closeSession(session);
2278        }
2279    }
2280
2281    protected WikiPage getByN_P_PrevAndNext(Session session, WikiPage wikiPage,
2282        long nodeId, String parentTitle, OrderByComparator orderByComparator,
2283        boolean previous) {
2284        StringBundler query = null;
2285
2286        if (orderByComparator != null) {
2287            query = new StringBundler(6 +
2288                    (orderByComparator.getOrderByFields().length * 6));
2289        }
2290        else {
2291            query = new StringBundler(3);
2292        }
2293
2294        query.append(_SQL_SELECT_WIKIPAGE_WHERE);
2295
2296        query.append(_FINDER_COLUMN_N_P_NODEID_2);
2297
2298        if (parentTitle == null) {
2299            query.append(_FINDER_COLUMN_N_P_PARENTTITLE_1);
2300        }
2301        else {
2302            if (parentTitle.equals(StringPool.BLANK)) {
2303                query.append(_FINDER_COLUMN_N_P_PARENTTITLE_3);
2304            }
2305            else {
2306                query.append(_FINDER_COLUMN_N_P_PARENTTITLE_2);
2307            }
2308        }
2309
2310        if (orderByComparator != null) {
2311            String[] orderByFields = orderByComparator.getOrderByFields();
2312
2313            if (orderByFields.length > 0) {
2314                query.append(WHERE_AND);
2315            }
2316
2317            for (int i = 0; i < orderByFields.length; i++) {
2318                query.append(_ORDER_BY_ENTITY_ALIAS);
2319                query.append(orderByFields[i]);
2320
2321                if ((i + 1) < orderByFields.length) {
2322                    if (orderByComparator.isAscending() ^ previous) {
2323                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
2324                    }
2325                    else {
2326                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
2327                    }
2328                }
2329                else {
2330                    if (orderByComparator.isAscending() ^ previous) {
2331                        query.append(WHERE_GREATER_THAN);
2332                    }
2333                    else {
2334                        query.append(WHERE_LESSER_THAN);
2335                    }
2336                }
2337            }
2338
2339            query.append(ORDER_BY_CLAUSE);
2340
2341            for (int i = 0; i < orderByFields.length; i++) {
2342                query.append(_ORDER_BY_ENTITY_ALIAS);
2343                query.append(orderByFields[i]);
2344
2345                if ((i + 1) < orderByFields.length) {
2346                    if (orderByComparator.isAscending() ^ previous) {
2347                        query.append(ORDER_BY_ASC_HAS_NEXT);
2348                    }
2349                    else {
2350                        query.append(ORDER_BY_DESC_HAS_NEXT);
2351                    }
2352                }
2353                else {
2354                    if (orderByComparator.isAscending() ^ previous) {
2355                        query.append(ORDER_BY_ASC);
2356                    }
2357                    else {
2358                        query.append(ORDER_BY_DESC);
2359                    }
2360                }
2361            }
2362        }
2363
2364        else {
2365            query.append(WikiPageModelImpl.ORDER_BY_JPQL);
2366        }
2367
2368        String sql = query.toString();
2369
2370        Query q = session.createQuery(sql);
2371
2372        q.setFirstResult(0);
2373        q.setMaxResults(2);
2374
2375        QueryPos qPos = QueryPos.getInstance(q);
2376
2377        qPos.add(nodeId);
2378
2379        if (parentTitle != null) {
2380            qPos.add(parentTitle);
2381        }
2382
2383        if (orderByComparator != null) {
2384            Object[] values = orderByComparator.getOrderByValues(wikiPage);
2385
2386            for (Object value : values) {
2387                qPos.add(value);
2388            }
2389        }
2390
2391        List<WikiPage> list = q.list();
2392
2393        if (list.size() == 2) {
2394            return list.get(1);
2395        }
2396        else {
2397            return null;
2398        }
2399    }
2400
2401    public List<WikiPage> findByN_R(long nodeId, String redirectTitle)
2402        throws SystemException {
2403        return findByN_R(nodeId, redirectTitle, QueryUtil.ALL_POS,
2404            QueryUtil.ALL_POS, null);
2405    }
2406
2407    public List<WikiPage> findByN_R(long nodeId, String redirectTitle,
2408        int start, int end) throws SystemException {
2409        return findByN_R(nodeId, redirectTitle, start, end, null);
2410    }
2411
2412    public List<WikiPage> findByN_R(long nodeId, String redirectTitle,
2413        int start, int end, OrderByComparator orderByComparator)
2414        throws SystemException {
2415        Object[] finderArgs = new Object[] {
2416                nodeId, redirectTitle,
2417                
2418                String.valueOf(start), String.valueOf(end),
2419                String.valueOf(orderByComparator)
2420            };
2421
2422        List<WikiPage> list = (List<WikiPage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_N_R,
2423                finderArgs, this);
2424
2425        if (list == null) {
2426            StringBundler query = null;
2427
2428            if (orderByComparator != null) {
2429                query = new StringBundler(4 +
2430                        (orderByComparator.getOrderByFields().length * 3));
2431            }
2432            else {
2433                query = new StringBundler(4);
2434            }
2435
2436            query.append(_SQL_SELECT_WIKIPAGE_WHERE);
2437
2438            query.append(_FINDER_COLUMN_N_R_NODEID_2);
2439
2440            if (redirectTitle == null) {
2441                query.append(_FINDER_COLUMN_N_R_REDIRECTTITLE_1);
2442            }
2443            else {
2444                if (redirectTitle.equals(StringPool.BLANK)) {
2445                    query.append(_FINDER_COLUMN_N_R_REDIRECTTITLE_3);
2446                }
2447                else {
2448                    query.append(_FINDER_COLUMN_N_R_REDIRECTTITLE_2);
2449                }
2450            }
2451
2452            if (orderByComparator != null) {
2453                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2454                    orderByComparator);
2455            }
2456
2457            else {
2458                query.append(WikiPageModelImpl.ORDER_BY_JPQL);
2459            }
2460
2461            String sql = query.toString();
2462
2463            Session session = null;
2464
2465            try {
2466                session = openSession();
2467
2468                Query q = session.createQuery(sql);
2469
2470                QueryPos qPos = QueryPos.getInstance(q);
2471
2472                qPos.add(nodeId);
2473
2474                if (redirectTitle != null) {
2475                    qPos.add(redirectTitle);
2476                }
2477
2478                list = (List<WikiPage>)QueryUtil.list(q, getDialect(), start,
2479                        end);
2480            }
2481            catch (Exception e) {
2482                throw processException(e);
2483            }
2484            finally {
2485                if (list == null) {
2486                    list = new ArrayList<WikiPage>();
2487                }
2488
2489                cacheResult(list);
2490
2491                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_N_R, finderArgs,
2492                    list);
2493
2494                closeSession(session);
2495            }
2496        }
2497
2498        return list;
2499    }
2500
2501    public WikiPage findByN_R_First(long nodeId, String redirectTitle,
2502        OrderByComparator orderByComparator)
2503        throws NoSuchPageException, SystemException {
2504        List<WikiPage> list = findByN_R(nodeId, redirectTitle, 0, 1,
2505                orderByComparator);
2506
2507        if (list.isEmpty()) {
2508            StringBundler msg = new StringBundler(6);
2509
2510            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2511
2512            msg.append("nodeId=");
2513            msg.append(nodeId);
2514
2515            msg.append(", redirectTitle=");
2516            msg.append(redirectTitle);
2517
2518            msg.append(StringPool.CLOSE_CURLY_BRACE);
2519
2520            throw new NoSuchPageException(msg.toString());
2521        }
2522        else {
2523            return list.get(0);
2524        }
2525    }
2526
2527    public WikiPage findByN_R_Last(long nodeId, String redirectTitle,
2528        OrderByComparator orderByComparator)
2529        throws NoSuchPageException, SystemException {
2530        int count = countByN_R(nodeId, redirectTitle);
2531
2532        List<WikiPage> list = findByN_R(nodeId, redirectTitle, count - 1,
2533                count, orderByComparator);
2534
2535        if (list.isEmpty()) {
2536            StringBundler msg = new StringBundler(6);
2537
2538            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2539
2540            msg.append("nodeId=");
2541            msg.append(nodeId);
2542
2543            msg.append(", redirectTitle=");
2544            msg.append(redirectTitle);
2545
2546            msg.append(StringPool.CLOSE_CURLY_BRACE);
2547
2548            throw new NoSuchPageException(msg.toString());
2549        }
2550        else {
2551            return list.get(0);
2552        }
2553    }
2554
2555    public WikiPage[] findByN_R_PrevAndNext(long pageId, long nodeId,
2556        String redirectTitle, OrderByComparator orderByComparator)
2557        throws NoSuchPageException, SystemException {
2558        WikiPage wikiPage = findByPrimaryKey(pageId);
2559
2560        Session session = null;
2561
2562        try {
2563            session = openSession();
2564
2565            WikiPage[] array = new WikiPageImpl[3];
2566
2567            array[0] = getByN_R_PrevAndNext(session, wikiPage, nodeId,
2568                    redirectTitle, orderByComparator, true);
2569
2570            array[1] = wikiPage;
2571
2572            array[2] = getByN_R_PrevAndNext(session, wikiPage, nodeId,
2573                    redirectTitle, orderByComparator, false);
2574
2575            return array;
2576        }
2577        catch (Exception e) {
2578            throw processException(e);
2579        }
2580        finally {
2581            closeSession(session);
2582        }
2583    }
2584
2585    protected WikiPage getByN_R_PrevAndNext(Session session, WikiPage wikiPage,
2586        long nodeId, String redirectTitle, OrderByComparator orderByComparator,
2587        boolean previous) {
2588        StringBundler query = null;
2589
2590        if (orderByComparator != null) {
2591            query = new StringBundler(6 +
2592                    (orderByComparator.getOrderByFields().length * 6));
2593        }
2594        else {
2595            query = new StringBundler(3);
2596        }
2597
2598        query.append(_SQL_SELECT_WIKIPAGE_WHERE);
2599
2600        query.append(_FINDER_COLUMN_N_R_NODEID_2);
2601
2602        if (redirectTitle == null) {
2603            query.append(_FINDER_COLUMN_N_R_REDIRECTTITLE_1);
2604        }
2605        else {
2606            if (redirectTitle.equals(StringPool.BLANK)) {
2607                query.append(_FINDER_COLUMN_N_R_REDIRECTTITLE_3);
2608            }
2609            else {
2610                query.append(_FINDER_COLUMN_N_R_REDIRECTTITLE_2);
2611            }
2612        }
2613
2614        if (orderByComparator != null) {
2615            String[] orderByFields = orderByComparator.getOrderByFields();
2616
2617            if (orderByFields.length > 0) {
2618                query.append(WHERE_AND);
2619            }
2620
2621            for (int i = 0; i < orderByFields.length; i++) {
2622                query.append(_ORDER_BY_ENTITY_ALIAS);
2623                query.append(orderByFields[i]);
2624
2625                if ((i + 1) < orderByFields.length) {
2626                    if (orderByComparator.isAscending() ^ previous) {
2627                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
2628                    }
2629                    else {
2630                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
2631                    }
2632                }
2633                else {
2634                    if (orderByComparator.isAscending() ^ previous) {
2635                        query.append(WHERE_GREATER_THAN);
2636                    }
2637                    else {
2638                        query.append(WHERE_LESSER_THAN);
2639                    }
2640                }
2641            }
2642
2643            query.append(ORDER_BY_CLAUSE);
2644
2645            for (int i = 0; i < orderByFields.length; i++) {
2646                query.append(_ORDER_BY_ENTITY_ALIAS);
2647                query.append(orderByFields[i]);
2648
2649                if ((i + 1) < orderByFields.length) {
2650                    if (orderByComparator.isAscending() ^ previous) {
2651                        query.append(ORDER_BY_ASC_HAS_NEXT);
2652                    }
2653                    else {
2654                        query.append(ORDER_BY_DESC_HAS_NEXT);
2655                    }
2656                }
2657                else {
2658                    if (orderByComparator.isAscending() ^ previous) {
2659                        query.append(ORDER_BY_ASC);
2660                    }
2661                    else {
2662                        query.append(ORDER_BY_DESC);
2663                    }
2664                }
2665            }
2666        }
2667
2668        else {
2669            query.append(WikiPageModelImpl.ORDER_BY_JPQL);
2670        }
2671
2672        String sql = query.toString();
2673
2674        Query q = session.createQuery(sql);
2675
2676        q.setFirstResult(0);
2677        q.setMaxResults(2);
2678
2679        QueryPos qPos = QueryPos.getInstance(q);
2680
2681        qPos.add(nodeId);
2682
2683        if (redirectTitle != null) {
2684            qPos.add(redirectTitle);
2685        }
2686
2687        if (orderByComparator != null) {
2688            Object[] values = orderByComparator.getOrderByValues(wikiPage);
2689
2690            for (Object value : values) {
2691                qPos.add(value);
2692            }
2693        }
2694
2695        List<WikiPage> list = q.list();
2696
2697        if (list.size() == 2) {
2698            return list.get(1);
2699        }
2700        else {
2701            return null;
2702        }
2703    }
2704
2705    public WikiPage findByN_T_V(long nodeId, String title, double version)
2706        throws NoSuchPageException, SystemException {
2707        WikiPage wikiPage = fetchByN_T_V(nodeId, title, version);
2708
2709        if (wikiPage == null) {
2710            StringBundler msg = new StringBundler(8);
2711
2712            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2713
2714            msg.append("nodeId=");
2715            msg.append(nodeId);
2716
2717            msg.append(", title=");
2718            msg.append(title);
2719
2720            msg.append(", version=");
2721            msg.append(version);
2722
2723            msg.append(StringPool.CLOSE_CURLY_BRACE);
2724
2725            if (_log.isWarnEnabled()) {
2726                _log.warn(msg.toString());
2727            }
2728
2729            throw new NoSuchPageException(msg.toString());
2730        }
2731
2732        return wikiPage;
2733    }
2734
2735    public WikiPage fetchByN_T_V(long nodeId, String title, double version)
2736        throws SystemException {
2737        return fetchByN_T_V(nodeId, title, version, true);
2738    }
2739
2740    public WikiPage fetchByN_T_V(long nodeId, String title, double version,
2741        boolean retrieveFromCache) throws SystemException {
2742        Object[] finderArgs = new Object[] { nodeId, title, version };
2743
2744        Object result = null;
2745
2746        if (retrieveFromCache) {
2747            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_N_T_V,
2748                    finderArgs, this);
2749        }
2750
2751        if (result == null) {
2752            StringBundler query = new StringBundler(5);
2753
2754            query.append(_SQL_SELECT_WIKIPAGE_WHERE);
2755
2756            query.append(_FINDER_COLUMN_N_T_V_NODEID_2);
2757
2758            if (title == null) {
2759                query.append(_FINDER_COLUMN_N_T_V_TITLE_1);
2760            }
2761            else {
2762                if (title.equals(StringPool.BLANK)) {
2763                    query.append(_FINDER_COLUMN_N_T_V_TITLE_3);
2764                }
2765                else {
2766                    query.append(_FINDER_COLUMN_N_T_V_TITLE_2);
2767                }
2768            }
2769
2770            query.append(_FINDER_COLUMN_N_T_V_VERSION_2);
2771
2772            query.append(WikiPageModelImpl.ORDER_BY_JPQL);
2773
2774            String sql = query.toString();
2775
2776            Session session = null;
2777
2778            try {
2779                session = openSession();
2780
2781                Query q = session.createQuery(sql);
2782
2783                QueryPos qPos = QueryPos.getInstance(q);
2784
2785                qPos.add(nodeId);
2786
2787                if (title != null) {
2788                    qPos.add(title);
2789                }
2790
2791                qPos.add(version);
2792
2793                List<WikiPage> list = q.list();
2794
2795                result = list;
2796
2797                WikiPage wikiPage = null;
2798
2799                if (list.isEmpty()) {
2800                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_N_T_V,
2801                        finderArgs, list);
2802                }
2803                else {
2804                    wikiPage = list.get(0);
2805
2806                    cacheResult(wikiPage);
2807
2808                    if ((wikiPage.getNodeId() != nodeId) ||
2809                            (wikiPage.getTitle() == null) ||
2810                            !wikiPage.getTitle().equals(title) ||
2811                            (wikiPage.getVersion() != version)) {
2812                        FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_N_T_V,
2813                            finderArgs, wikiPage);
2814                    }
2815                }
2816
2817                return wikiPage;
2818            }
2819            catch (Exception e) {
2820                throw processException(e);
2821            }
2822            finally {
2823                if (result == null) {
2824                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_N_T_V,
2825                        finderArgs, new ArrayList<WikiPage>());
2826                }
2827
2828                closeSession(session);
2829            }
2830        }
2831        else {
2832            if (result instanceof List<?>) {
2833                return null;
2834            }
2835            else {
2836                return (WikiPage)result;
2837            }
2838        }
2839    }
2840
2841    public List<WikiPage> findByN_T_H(long nodeId, String title, boolean head)
2842        throws SystemException {
2843        return findByN_T_H(nodeId, title, head, QueryUtil.ALL_POS,
2844            QueryUtil.ALL_POS, null);
2845    }
2846
2847    public List<WikiPage> findByN_T_H(long nodeId, String title, boolean head,
2848        int start, int end) throws SystemException {
2849        return findByN_T_H(nodeId, title, head, start, end, null);
2850    }
2851
2852    public List<WikiPage> findByN_T_H(long nodeId, String title, boolean head,
2853        int start, int end, OrderByComparator orderByComparator)
2854        throws SystemException {
2855        Object[] finderArgs = new Object[] {
2856                nodeId, title, head,
2857                
2858                String.valueOf(start), String.valueOf(end),
2859                String.valueOf(orderByComparator)
2860            };
2861
2862        List<WikiPage> list = (List<WikiPage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_N_T_H,
2863                finderArgs, this);
2864
2865        if (list == null) {
2866            StringBundler query = null;
2867
2868            if (orderByComparator != null) {
2869                query = new StringBundler(5 +
2870                        (orderByComparator.getOrderByFields().length * 3));
2871            }
2872            else {
2873                query = new StringBundler(5);
2874            }
2875
2876            query.append(_SQL_SELECT_WIKIPAGE_WHERE);
2877
2878            query.append(_FINDER_COLUMN_N_T_H_NODEID_2);
2879
2880            if (title == null) {
2881                query.append(_FINDER_COLUMN_N_T_H_TITLE_1);
2882            }
2883            else {
2884                if (title.equals(StringPool.BLANK)) {
2885                    query.append(_FINDER_COLUMN_N_T_H_TITLE_3);
2886                }
2887                else {
2888                    query.append(_FINDER_COLUMN_N_T_H_TITLE_2);
2889                }
2890            }
2891
2892            query.append(_FINDER_COLUMN_N_T_H_HEAD_2);
2893
2894            if (orderByComparator != null) {
2895                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2896                    orderByComparator);
2897            }
2898
2899            else {
2900                query.append(WikiPageModelImpl.ORDER_BY_JPQL);
2901            }
2902
2903            String sql = query.toString();
2904
2905            Session session = null;
2906
2907            try {
2908                session = openSession();
2909
2910                Query q = session.createQuery(sql);
2911
2912                QueryPos qPos = QueryPos.getInstance(q);
2913
2914                qPos.add(nodeId);
2915
2916                if (title != null) {
2917                    qPos.add(title);
2918                }
2919
2920                qPos.add(head);
2921
2922                list = (List<WikiPage>)QueryUtil.list(q, getDialect(), start,
2923                        end);
2924            }
2925            catch (Exception e) {
2926                throw processException(e);
2927            }
2928            finally {
2929                if (list == null) {
2930                    list = new ArrayList<WikiPage>();
2931                }
2932
2933                cacheResult(list);
2934
2935                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_N_T_H,
2936                    finderArgs, list);
2937
2938                closeSession(session);
2939            }
2940        }
2941
2942        return list;
2943    }
2944
2945    public WikiPage findByN_T_H_First(long nodeId, String title, boolean head,
2946        OrderByComparator orderByComparator)
2947        throws NoSuchPageException, SystemException {
2948        List<WikiPage> list = findByN_T_H(nodeId, title, head, 0, 1,
2949                orderByComparator);
2950
2951        if (list.isEmpty()) {
2952            StringBundler msg = new StringBundler(8);
2953
2954            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2955
2956            msg.append("nodeId=");
2957            msg.append(nodeId);
2958
2959            msg.append(", title=");
2960            msg.append(title);
2961
2962            msg.append(", head=");
2963            msg.append(head);
2964
2965            msg.append(StringPool.CLOSE_CURLY_BRACE);
2966
2967            throw new NoSuchPageException(msg.toString());
2968        }
2969        else {
2970            return list.get(0);
2971        }
2972    }
2973
2974    public WikiPage findByN_T_H_Last(long nodeId, String title, boolean head,
2975        OrderByComparator orderByComparator)
2976        throws NoSuchPageException, SystemException {
2977        int count = countByN_T_H(nodeId, title, head);
2978
2979        List<WikiPage> list = findByN_T_H(nodeId, title, head, count - 1,
2980                count, orderByComparator);
2981
2982        if (list.isEmpty()) {
2983            StringBundler msg = new StringBundler(8);
2984
2985            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2986
2987            msg.append("nodeId=");
2988            msg.append(nodeId);
2989
2990            msg.append(", title=");
2991            msg.append(title);
2992
2993            msg.append(", head=");
2994            msg.append(head);
2995
2996            msg.append(StringPool.CLOSE_CURLY_BRACE);
2997
2998            throw new NoSuchPageException(msg.toString());
2999        }
3000        else {
3001            return list.get(0);
3002        }
3003    }
3004
3005    public WikiPage[] findByN_T_H_PrevAndNext(long pageId, long nodeId,
3006        String title, boolean head, OrderByComparator orderByComparator)
3007        throws NoSuchPageException, SystemException {
3008        WikiPage wikiPage = findByPrimaryKey(pageId);
3009
3010        Session session = null;
3011
3012        try {
3013            session = openSession();
3014
3015            WikiPage[] array = new WikiPageImpl[3];
3016
3017            array[0] = getByN_T_H_PrevAndNext(session, wikiPage, nodeId, title,
3018                    head, orderByComparator, true);
3019
3020            array[1] = wikiPage;
3021
3022            array[2] = getByN_T_H_PrevAndNext(session, wikiPage, nodeId, title,
3023                    head, orderByComparator, false);
3024
3025            return array;
3026        }
3027        catch (Exception e) {
3028            throw processException(e);
3029        }
3030        finally {
3031            closeSession(session);
3032        }
3033    }
3034
3035    protected WikiPage getByN_T_H_PrevAndNext(Session session,
3036        WikiPage wikiPage, long nodeId, String title, boolean head,
3037        OrderByComparator orderByComparator, boolean previous) {
3038        StringBundler query = null;
3039
3040        if (orderByComparator != null) {
3041            query = new StringBundler(6 +
3042                    (orderByComparator.getOrderByFields().length * 6));
3043        }
3044        else {
3045            query = new StringBundler(3);
3046        }
3047
3048        query.append(_SQL_SELECT_WIKIPAGE_WHERE);
3049
3050        query.append(_FINDER_COLUMN_N_T_H_NODEID_2);
3051
3052        if (title == null) {
3053            query.append(_FINDER_COLUMN_N_T_H_TITLE_1);
3054        }
3055        else {
3056            if (title.equals(StringPool.BLANK)) {
3057                query.append(_FINDER_COLUMN_N_T_H_TITLE_3);
3058            }
3059            else {
3060                query.append(_FINDER_COLUMN_N_T_H_TITLE_2);
3061            }
3062        }
3063
3064        query.append(_FINDER_COLUMN_N_T_H_HEAD_2);
3065
3066        if (orderByComparator != null) {
3067            String[] orderByFields = orderByComparator.getOrderByFields();
3068
3069            if (orderByFields.length > 0) {
3070                query.append(WHERE_AND);
3071            }
3072
3073            for (int i = 0; i < orderByFields.length; i++) {
3074                query.append(_ORDER_BY_ENTITY_ALIAS);
3075                query.append(orderByFields[i]);
3076
3077                if ((i + 1) < orderByFields.length) {
3078                    if (orderByComparator.isAscending() ^ previous) {
3079                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
3080                    }
3081                    else {
3082                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
3083                    }
3084                }
3085                else {
3086                    if (orderByComparator.isAscending() ^ previous) {
3087                        query.append(WHERE_GREATER_THAN);
3088                    }
3089                    else {
3090                        query.append(WHERE_LESSER_THAN);
3091                    }
3092                }
3093            }
3094
3095            query.append(ORDER_BY_CLAUSE);
3096
3097            for (int i = 0; i < orderByFields.length; i++) {
3098                query.append(_ORDER_BY_ENTITY_ALIAS);
3099                query.append(orderByFields[i]);
3100
3101                if ((i + 1) < orderByFields.length) {
3102                    if (orderByComparator.isAscending() ^ previous) {
3103                        query.append(ORDER_BY_ASC_HAS_NEXT);
3104                    }
3105                    else {
3106                        query.append(ORDER_BY_DESC_HAS_NEXT);
3107                    }
3108                }
3109                else {
3110                    if (orderByComparator.isAscending() ^ previous) {
3111                        query.append(ORDER_BY_ASC);
3112                    }
3113                    else {
3114                        query.append(ORDER_BY_DESC);
3115                    }
3116                }
3117            }
3118        }
3119
3120        else {
3121            query.append(WikiPageModelImpl.ORDER_BY_JPQL);
3122        }
3123
3124        String sql = query.toString();
3125
3126        Query q = session.createQuery(sql);
3127
3128        q.setFirstResult(0);
3129        q.setMaxResults(2);
3130
3131        QueryPos qPos = QueryPos.getInstance(q);
3132
3133        qPos.add(nodeId);
3134
3135        if (title != null) {
3136            qPos.add(title);
3137        }
3138
3139        qPos.add(head);
3140
3141        if (orderByComparator != null) {
3142            Object[] values = orderByComparator.getOrderByValues(wikiPage);
3143
3144            for (Object value : values) {
3145                qPos.add(value);
3146            }
3147        }
3148
3149        List<WikiPage> list = q.list();
3150
3151        if (list.size() == 2) {
3152            return list.get(1);
3153        }
3154        else {
3155            return null;
3156        }
3157    }
3158
3159    public List<WikiPage> findByN_H_P(long nodeId, boolean head,
3160        String parentTitle) throws SystemException {
3161        return findByN_H_P(nodeId, head, parentTitle, QueryUtil.ALL_POS,
3162            QueryUtil.ALL_POS, null);
3163    }
3164
3165    public List<WikiPage> findByN_H_P(long nodeId, boolean head,
3166        String parentTitle, int start, int end) throws SystemException {
3167        return findByN_H_P(nodeId, head, parentTitle, start, end, null);
3168    }
3169
3170    public List<WikiPage> findByN_H_P(long nodeId, boolean head,
3171        String parentTitle, int start, int end,
3172        OrderByComparator orderByComparator) throws SystemException {
3173        Object[] finderArgs = new Object[] {
3174                nodeId, head, parentTitle,
3175                
3176                String.valueOf(start), String.valueOf(end),
3177                String.valueOf(orderByComparator)
3178            };
3179
3180        List<WikiPage> list = (List<WikiPage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_N_H_P,
3181                finderArgs, this);
3182
3183        if (list == null) {
3184            StringBundler query = null;
3185
3186            if (orderByComparator != null) {
3187                query = new StringBundler(5 +
3188                        (orderByComparator.getOrderByFields().length * 3));
3189            }
3190            else {
3191                query = new StringBundler(5);
3192            }
3193
3194            query.append(_SQL_SELECT_WIKIPAGE_WHERE);
3195
3196            query.append(_FINDER_COLUMN_N_H_P_NODEID_2);
3197
3198            query.append(_FINDER_COLUMN_N_H_P_HEAD_2);
3199
3200            if (parentTitle == null) {
3201                query.append(_FINDER_COLUMN_N_H_P_PARENTTITLE_1);
3202            }
3203            else {
3204                if (parentTitle.equals(StringPool.BLANK)) {
3205                    query.append(_FINDER_COLUMN_N_H_P_PARENTTITLE_3);
3206                }
3207                else {
3208                    query.append(_FINDER_COLUMN_N_H_P_PARENTTITLE_2);
3209                }
3210            }
3211
3212            if (orderByComparator != null) {
3213                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
3214                    orderByComparator);
3215            }
3216
3217            else {
3218                query.append(WikiPageModelImpl.ORDER_BY_JPQL);
3219            }
3220
3221            String sql = query.toString();
3222
3223            Session session = null;
3224
3225            try {
3226                session = openSession();
3227
3228                Query q = session.createQuery(sql);
3229
3230                QueryPos qPos = QueryPos.getInstance(q);
3231
3232                qPos.add(nodeId);
3233
3234                qPos.add(head);
3235
3236                if (parentTitle != null) {
3237                    qPos.add(parentTitle);
3238                }
3239
3240                list = (List<WikiPage>)QueryUtil.list(q, getDialect(), start,
3241                        end);
3242            }
3243            catch (Exception e) {
3244                throw processException(e);
3245            }
3246            finally {
3247                if (list == null) {
3248                    list = new ArrayList<WikiPage>();
3249                }
3250
3251                cacheResult(list);
3252
3253                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_N_H_P,
3254                    finderArgs, list);
3255
3256                closeSession(session);
3257            }
3258        }
3259
3260        return list;
3261    }
3262
3263    public WikiPage findByN_H_P_First(long nodeId, boolean head,
3264        String parentTitle, OrderByComparator orderByComparator)
3265        throws NoSuchPageException, SystemException {
3266        List<WikiPage> list = findByN_H_P(nodeId, head, parentTitle, 0, 1,
3267                orderByComparator);
3268
3269        if (list.isEmpty()) {
3270            StringBundler msg = new StringBundler(8);
3271
3272            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3273
3274            msg.append("nodeId=");
3275            msg.append(nodeId);
3276
3277            msg.append(", head=");
3278            msg.append(head);
3279
3280            msg.append(", parentTitle=");
3281            msg.append(parentTitle);
3282
3283            msg.append(StringPool.CLOSE_CURLY_BRACE);
3284
3285            throw new NoSuchPageException(msg.toString());
3286        }
3287        else {
3288            return list.get(0);
3289        }
3290    }
3291
3292    public WikiPage findByN_H_P_Last(long nodeId, boolean head,
3293        String parentTitle, OrderByComparator orderByComparator)
3294        throws NoSuchPageException, SystemException {
3295        int count = countByN_H_P(nodeId, head, parentTitle);
3296
3297        List<WikiPage> list = findByN_H_P(nodeId, head, parentTitle, count - 1,
3298                count, orderByComparator);
3299
3300        if (list.isEmpty()) {
3301            StringBundler msg = new StringBundler(8);
3302
3303            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3304
3305            msg.append("nodeId=");
3306            msg.append(nodeId);
3307
3308            msg.append(", head=");
3309            msg.append(head);
3310
3311            msg.append(", parentTitle=");
3312            msg.append(parentTitle);
3313
3314            msg.append(StringPool.CLOSE_CURLY_BRACE);
3315
3316            throw new NoSuchPageException(msg.toString());
3317        }
3318        else {
3319            return list.get(0);
3320        }
3321    }
3322
3323    public WikiPage[] findByN_H_P_PrevAndNext(long pageId, long nodeId,
3324        boolean head, String parentTitle, OrderByComparator orderByComparator)
3325        throws NoSuchPageException, SystemException {
3326        WikiPage wikiPage = findByPrimaryKey(pageId);
3327
3328        Session session = null;
3329
3330        try {
3331            session = openSession();
3332
3333            WikiPage[] array = new WikiPageImpl[3];
3334
3335            array[0] = getByN_H_P_PrevAndNext(session, wikiPage, nodeId, head,
3336                    parentTitle, orderByComparator, true);
3337
3338            array[1] = wikiPage;
3339
3340            array[2] = getByN_H_P_PrevAndNext(session, wikiPage, nodeId, head,
3341                    parentTitle, orderByComparator, false);
3342
3343            return array;
3344        }
3345        catch (Exception e) {
3346            throw processException(e);
3347        }
3348        finally {
3349            closeSession(session);
3350        }
3351    }
3352
3353    protected WikiPage getByN_H_P_PrevAndNext(Session session,
3354        WikiPage wikiPage, long nodeId, boolean head, String parentTitle,
3355        OrderByComparator orderByComparator, boolean previous) {
3356        StringBundler query = null;
3357
3358        if (orderByComparator != null) {
3359            query = new StringBundler(6 +
3360                    (orderByComparator.getOrderByFields().length * 6));
3361        }
3362        else {
3363            query = new StringBundler(3);
3364        }
3365
3366        query.append(_SQL_SELECT_WIKIPAGE_WHERE);
3367
3368        query.append(_FINDER_COLUMN_N_H_P_NODEID_2);
3369
3370        query.append(_FINDER_COLUMN_N_H_P_HEAD_2);
3371
3372        if (parentTitle == null) {
3373            query.append(_FINDER_COLUMN_N_H_P_PARENTTITLE_1);
3374        }
3375        else {
3376            if (parentTitle.equals(StringPool.BLANK)) {
3377                query.append(_FINDER_COLUMN_N_H_P_PARENTTITLE_3);
3378            }
3379            else {
3380                query.append(_FINDER_COLUMN_N_H_P_PARENTTITLE_2);
3381            }
3382        }
3383
3384        if (orderByComparator != null) {
3385            String[] orderByFields = orderByComparator.getOrderByFields();
3386
3387            if (orderByFields.length > 0) {
3388                query.append(WHERE_AND);
3389            }
3390
3391            for (int i = 0; i < orderByFields.length; i++) {
3392                query.append(_ORDER_BY_ENTITY_ALIAS);
3393                query.append(orderByFields[i]);
3394
3395                if ((i + 1) < orderByFields.length) {
3396                    if (orderByComparator.isAscending() ^ previous) {
3397                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
3398                    }
3399                    else {
3400                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
3401                    }
3402                }
3403                else {
3404                    if (orderByComparator.isAscending() ^ previous) {
3405                        query.append(WHERE_GREATER_THAN);
3406                    }
3407                    else {
3408                        query.append(WHERE_LESSER_THAN);
3409                    }
3410                }
3411            }
3412
3413            query.append(ORDER_BY_CLAUSE);
3414
3415            for (int i = 0; i < orderByFields.length; i++) {
3416                query.append(_ORDER_BY_ENTITY_ALIAS);
3417                query.append(orderByFields[i]);
3418
3419                if ((i + 1) < orderByFields.length) {
3420                    if (orderByComparator.isAscending() ^ previous) {
3421                        query.append(ORDER_BY_ASC_HAS_NEXT);
3422                    }
3423                    else {
3424                        query.append(ORDER_BY_DESC_HAS_NEXT);
3425                    }
3426                }
3427                else {
3428                    if (orderByComparator.isAscending() ^ previous) {
3429                        query.append(ORDER_BY_ASC);
3430                    }
3431                    else {
3432                        query.append(ORDER_BY_DESC);
3433                    }
3434                }
3435            }
3436        }
3437
3438        else {
3439            query.append(WikiPageModelImpl.ORDER_BY_JPQL);
3440        }
3441
3442        String sql = query.toString();
3443
3444        Query q = session.createQuery(sql);
3445
3446        q.setFirstResult(0);
3447        q.setMaxResults(2);
3448
3449        QueryPos qPos = QueryPos.getInstance(q);
3450
3451        qPos.add(nodeId);
3452
3453        qPos.add(head);
3454
3455        if (parentTitle != null) {
3456            qPos.add(parentTitle);
3457        }
3458
3459        if (orderByComparator != null) {
3460            Object[] values = orderByComparator.getOrderByValues(wikiPage);
3461
3462            for (Object value : values) {
3463                qPos.add(value);
3464            }
3465        }
3466
3467        List<WikiPage> list = q.list();
3468
3469        if (list.size() == 2) {
3470            return list.get(1);
3471        }
3472        else {
3473            return null;
3474        }
3475    }
3476
3477    public List<WikiPage> findAll() throws SystemException {
3478        return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
3479    }
3480
3481    public List<WikiPage> findAll(int start, int end) throws SystemException {
3482        return findAll(start, end, null);
3483    }
3484
3485    public List<WikiPage> findAll(int start, int end,
3486        OrderByComparator orderByComparator) throws SystemException {
3487        Object[] finderArgs = new Object[] {
3488                String.valueOf(start), String.valueOf(end),
3489                String.valueOf(orderByComparator)
3490            };
3491
3492        List<WikiPage> list = (List<WikiPage>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
3493                finderArgs, this);
3494
3495        if (list == null) {
3496            StringBundler query = null;
3497            String sql = null;
3498
3499            if (orderByComparator != null) {
3500                query = new StringBundler(2 +
3501                        (orderByComparator.getOrderByFields().length * 3));
3502
3503                query.append(_SQL_SELECT_WIKIPAGE);
3504
3505                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
3506                    orderByComparator);
3507
3508                sql = query.toString();
3509            }
3510            else {
3511                sql = _SQL_SELECT_WIKIPAGE.concat(WikiPageModelImpl.ORDER_BY_JPQL);
3512            }
3513
3514            Session session = null;
3515
3516            try {
3517                session = openSession();
3518
3519                Query q = session.createQuery(sql);
3520
3521                if (orderByComparator == null) {
3522                    list = (List<WikiPage>)QueryUtil.list(q, getDialect(),
3523                            start, end, false);
3524
3525                    Collections.sort(list);
3526                }
3527                else {
3528                    list = (List<WikiPage>)QueryUtil.list(q, getDialect(),
3529                            start, end);
3530                }
3531            }
3532            catch (Exception e) {
3533                throw processException(e);
3534            }
3535            finally {
3536                if (list == null) {
3537                    list = new ArrayList<WikiPage>();
3538                }
3539
3540                cacheResult(list);
3541
3542                FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
3543
3544                closeSession(session);
3545            }
3546        }
3547
3548        return list;
3549    }
3550
3551    public void removeByUuid(String uuid) throws SystemException {
3552        for (WikiPage wikiPage : findByUuid(uuid)) {
3553            remove(wikiPage);
3554        }
3555    }
3556
3557    public void removeByUUID_G(String uuid, long groupId)
3558        throws NoSuchPageException, SystemException {
3559        WikiPage wikiPage = findByUUID_G(uuid, groupId);
3560
3561        remove(wikiPage);
3562    }
3563
3564    public void removeByNodeId(long nodeId) throws SystemException {
3565        for (WikiPage wikiPage : findByNodeId(nodeId)) {
3566            remove(wikiPage);
3567        }
3568    }
3569
3570    public void removeByFormat(String format) throws SystemException {
3571        for (WikiPage wikiPage : findByFormat(format)) {
3572            remove(wikiPage);
3573        }
3574    }
3575
3576    public void removeByN_T(long nodeId, String title)
3577        throws SystemException {
3578        for (WikiPage wikiPage : findByN_T(nodeId, title)) {
3579            remove(wikiPage);
3580        }
3581    }
3582
3583    public void removeByN_H(long nodeId, boolean head)
3584        throws SystemException {
3585        for (WikiPage wikiPage : findByN_H(nodeId, head)) {
3586            remove(wikiPage);
3587        }
3588    }
3589
3590    public void removeByN_P(long nodeId, String parentTitle)
3591        throws SystemException {
3592        for (WikiPage wikiPage : findByN_P(nodeId, parentTitle)) {
3593            remove(wikiPage);
3594        }
3595    }
3596
3597    public void removeByN_R(long nodeId, String redirectTitle)
3598        throws SystemException {
3599        for (WikiPage wikiPage : findByN_R(nodeId, redirectTitle)) {
3600            remove(wikiPage);
3601        }
3602    }
3603
3604    public void removeByN_T_V(long nodeId, String title, double version)
3605        throws NoSuchPageException, SystemException {
3606        WikiPage wikiPage = findByN_T_V(nodeId, title, version);
3607
3608        remove(wikiPage);
3609    }
3610
3611    public void removeByN_T_H(long nodeId, String title, boolean head)
3612        throws SystemException {
3613        for (WikiPage wikiPage : findByN_T_H(nodeId, title, head)) {
3614            remove(wikiPage);
3615        }
3616    }
3617
3618    public void removeByN_H_P(long nodeId, boolean head, String parentTitle)
3619        throws SystemException {
3620        for (WikiPage wikiPage : findByN_H_P(nodeId, head, parentTitle)) {
3621            remove(wikiPage);
3622        }
3623    }
3624
3625    public void removeAll() throws SystemException {
3626        for (WikiPage wikiPage : findAll()) {
3627            remove(wikiPage);
3628        }
3629    }
3630
3631    public int countByUuid(String uuid) throws SystemException {
3632        Object[] finderArgs = new Object[] { uuid };
3633
3634        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID,
3635                finderArgs, this);
3636
3637        if (count == null) {
3638            StringBundler query = new StringBundler(2);
3639
3640            query.append(_SQL_COUNT_WIKIPAGE_WHERE);
3641
3642            if (uuid == null) {
3643                query.append(_FINDER_COLUMN_UUID_UUID_1);
3644            }
3645            else {
3646                if (uuid.equals(StringPool.BLANK)) {
3647                    query.append(_FINDER_COLUMN_UUID_UUID_3);
3648                }
3649                else {
3650                    query.append(_FINDER_COLUMN_UUID_UUID_2);
3651                }
3652            }
3653
3654            String sql = query.toString();
3655
3656            Session session = null;
3657
3658            try {
3659                session = openSession();
3660
3661                Query q = session.createQuery(sql);
3662
3663                QueryPos qPos = QueryPos.getInstance(q);
3664
3665                if (uuid != null) {
3666                    qPos.add(uuid);
3667                }
3668
3669                count = (Long)q.uniqueResult();
3670            }
3671            catch (Exception e) {
3672                throw processException(e);
3673            }
3674            finally {
3675                if (count == null) {
3676                    count = Long.valueOf(0);
3677                }
3678
3679                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID,
3680                    finderArgs, count);
3681
3682                closeSession(session);
3683            }
3684        }
3685
3686        return count.intValue();
3687    }
3688
3689    public int countByUUID_G(String uuid, long groupId)
3690        throws SystemException {
3691        Object[] finderArgs = new Object[] { uuid, groupId };
3692
3693        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID_G,
3694                finderArgs, this);
3695
3696        if (count == null) {
3697            StringBundler query = new StringBundler(3);
3698
3699            query.append(_SQL_COUNT_WIKIPAGE_WHERE);
3700
3701            if (uuid == null) {
3702                query.append(_FINDER_COLUMN_UUID_G_UUID_1);
3703            }
3704            else {
3705                if (uuid.equals(StringPool.BLANK)) {
3706                    query.append(_FINDER_COLUMN_UUID_G_UUID_3);
3707                }
3708                else {
3709                    query.append(_FINDER_COLUMN_UUID_G_UUID_2);
3710                }
3711            }
3712
3713            query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
3714
3715            String sql = query.toString();
3716
3717            Session session = null;
3718
3719            try {
3720                session = openSession();
3721
3722                Query q = session.createQuery(sql);
3723
3724                QueryPos qPos = QueryPos.getInstance(q);
3725
3726                if (uuid != null) {
3727                    qPos.add(uuid);
3728                }
3729
3730                qPos.add(groupId);
3731
3732                count = (Long)q.uniqueResult();
3733            }
3734            catch (Exception e) {
3735                throw processException(e);
3736            }
3737            finally {
3738                if (count == null) {
3739                    count = Long.valueOf(0);
3740                }
3741
3742                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID_G,
3743                    finderArgs, count);
3744
3745                closeSession(session);
3746            }
3747        }
3748
3749        return count.intValue();
3750    }
3751
3752    public int countByNodeId(long nodeId) throws SystemException {
3753        Object[] finderArgs = new Object[] { nodeId };
3754
3755        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_NODEID,
3756                finderArgs, this);
3757
3758        if (count == null) {
3759            StringBundler query = new StringBundler(2);
3760
3761            query.append(_SQL_COUNT_WIKIPAGE_WHERE);
3762
3763            query.append(_FINDER_COLUMN_NODEID_NODEID_2);
3764
3765            String sql = query.toString();
3766
3767            Session session = null;
3768
3769            try {
3770                session = openSession();
3771
3772                Query q = session.createQuery(sql);
3773
3774                QueryPos qPos = QueryPos.getInstance(q);
3775
3776                qPos.add(nodeId);
3777
3778                count = (Long)q.uniqueResult();
3779            }
3780            catch (Exception e) {
3781                throw processException(e);
3782            }
3783            finally {
3784                if (count == null) {
3785                    count = Long.valueOf(0);
3786                }
3787
3788                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_NODEID,
3789                    finderArgs, count);
3790
3791                closeSession(session);
3792            }
3793        }
3794
3795        return count.intValue();
3796    }
3797
3798    public int countByFormat(String format) throws SystemException {
3799        Object[] finderArgs = new Object[] { format };
3800
3801        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_FORMAT,
3802                finderArgs, this);
3803
3804        if (count == null) {
3805            StringBundler query = new StringBundler(2);
3806
3807            query.append(_SQL_COUNT_WIKIPAGE_WHERE);
3808
3809            if (format == null) {
3810                query.append(_FINDER_COLUMN_FORMAT_FORMAT_1);
3811            }
3812            else {
3813                if (format.equals(StringPool.BLANK)) {
3814                    query.append(_FINDER_COLUMN_FORMAT_FORMAT_3);
3815                }
3816                else {
3817                    query.append(_FINDER_COLUMN_FORMAT_FORMAT_2);
3818                }
3819            }
3820
3821            String sql = query.toString();
3822
3823            Session session = null;
3824
3825            try {
3826                session = openSession();
3827
3828                Query q = session.createQuery(sql);
3829
3830                QueryPos qPos = QueryPos.getInstance(q);
3831
3832                if (format != null) {
3833                    qPos.add(format);
3834                }
3835
3836                count = (Long)q.uniqueResult();
3837            }
3838            catch (Exception e) {
3839                throw processException(e);
3840            }
3841            finally {
3842                if (count == null) {
3843                    count = Long.valueOf(0);
3844                }
3845
3846                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_FORMAT,
3847                    finderArgs, count);
3848
3849                closeSession(session);
3850            }
3851        }
3852
3853        return count.intValue();
3854    }
3855
3856    public int countByN_T(long nodeId, String title) throws SystemException {
3857        Object[] finderArgs = new Object[] { nodeId, title };
3858
3859        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_N_T,
3860                finderArgs, this);
3861
3862        if (count == null) {
3863            StringBundler query = new StringBundler(3);
3864
3865            query.append(_SQL_COUNT_WIKIPAGE_WHERE);
3866
3867            query.append(_FINDER_COLUMN_N_T_NODEID_2);
3868
3869            if (title == null) {
3870                query.append(_FINDER_COLUMN_N_T_TITLE_1);
3871            }
3872            else {
3873                if (title.equals(StringPool.BLANK)) {
3874                    query.append(_FINDER_COLUMN_N_T_TITLE_3);
3875                }
3876                else {
3877                    query.append(_FINDER_COLUMN_N_T_TITLE_2);
3878                }
3879            }
3880
3881            String sql = query.toString();
3882
3883            Session session = null;
3884
3885            try {
3886                session = openSession();
3887
3888                Query q = session.createQuery(sql);
3889
3890                QueryPos qPos = QueryPos.getInstance(q);
3891
3892                qPos.add(nodeId);
3893
3894                if (title != null) {
3895                    qPos.add(title);
3896                }
3897
3898                count = (Long)q.uniqueResult();
3899            }
3900            catch (Exception e) {
3901                throw processException(e);
3902            }
3903            finally {
3904                if (count == null) {
3905                    count = Long.valueOf(0);
3906                }
3907
3908                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_N_T, finderArgs,
3909                    count);
3910
3911                closeSession(session);
3912            }
3913        }
3914
3915        return count.intValue();
3916    }
3917
3918    public int countByN_H(long nodeId, boolean head) throws SystemException {
3919        Object[] finderArgs = new Object[] { nodeId, head };
3920
3921        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_N_H,
3922                finderArgs, this);
3923
3924        if (count == null) {
3925            StringBundler query = new StringBundler(3);
3926
3927            query.append(_SQL_COUNT_WIKIPAGE_WHERE);
3928
3929            query.append(_FINDER_COLUMN_N_H_NODEID_2);
3930
3931            query.append(_FINDER_COLUMN_N_H_HEAD_2);
3932
3933            String sql = query.toString();
3934
3935            Session session = null;
3936
3937            try {
3938                session = openSession();
3939
3940                Query q = session.createQuery(sql);
3941
3942                QueryPos qPos = QueryPos.getInstance(q);
3943
3944                qPos.add(nodeId);
3945
3946                qPos.add(head);
3947
3948                count = (Long)q.uniqueResult();
3949            }
3950            catch (Exception e) {
3951                throw processException(e);
3952            }
3953            finally {
3954                if (count == null) {
3955                    count = Long.valueOf(0);
3956                }
3957
3958                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_N_H, finderArgs,
3959                    count);
3960
3961                closeSession(session);
3962            }
3963        }
3964
3965        return count.intValue();
3966    }
3967
3968    public int countByN_P(long nodeId, String parentTitle)
3969        throws SystemException {
3970        Object[] finderArgs = new Object[] { nodeId, parentTitle };
3971
3972        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_N_P,
3973                finderArgs, this);
3974
3975        if (count == null) {
3976            StringBundler query = new StringBundler(3);
3977
3978            query.append(_SQL_COUNT_WIKIPAGE_WHERE);
3979
3980            query.append(_FINDER_COLUMN_N_P_NODEID_2);
3981
3982            if (parentTitle == null) {
3983                query.append(_FINDER_COLUMN_N_P_PARENTTITLE_1);
3984            }
3985            else {
3986                if (parentTitle.equals(StringPool.BLANK)) {
3987                    query.append(_FINDER_COLUMN_N_P_PARENTTITLE_3);
3988                }
3989                else {
3990                    query.append(_FINDER_COLUMN_N_P_PARENTTITLE_2);
3991                }
3992            }
3993
3994            String sql = query.toString();
3995
3996            Session session = null;
3997
3998            try {
3999                session = openSession();
4000
4001                Query q = session.createQuery(sql);
4002
4003                QueryPos qPos = QueryPos.getInstance(q);
4004
4005                qPos.add(nodeId);
4006
4007                if (parentTitle != null) {
4008                    qPos.add(parentTitle);
4009                }
4010
4011                count = (Long)q.uniqueResult();
4012            }
4013            catch (Exception e) {
4014                throw processException(e);
4015            }
4016            finally {
4017                if (count == null) {
4018                    count = Long.valueOf(0);
4019                }
4020
4021                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_N_P, finderArgs,
4022                    count);
4023
4024                closeSession(session);
4025            }
4026        }
4027
4028        return count.intValue();
4029    }
4030
4031    public int countByN_R(long nodeId, String redirectTitle)
4032        throws SystemException {
4033        Object[] finderArgs = new Object[] { nodeId, redirectTitle };
4034
4035        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_N_R,
4036                finderArgs, this);
4037
4038        if (count == null) {
4039            StringBundler query = new StringBundler(3);
4040
4041            query.append(_SQL_COUNT_WIKIPAGE_WHERE);
4042
4043            query.append(_FINDER_COLUMN_N_R_NODEID_2);
4044
4045            if (redirectTitle == null) {
4046                query.append(_FINDER_COLUMN_N_R_REDIRECTTITLE_1);
4047            }
4048            else {
4049                if (redirectTitle.equals(StringPool.BLANK)) {
4050                    query.append(_FINDER_COLUMN_N_R_REDIRECTTITLE_3);
4051                }
4052                else {
4053                    query.append(_FINDER_COLUMN_N_R_REDIRECTTITLE_2);
4054                }
4055            }
4056
4057            String sql = query.toString();
4058
4059            Session session = null;
4060
4061            try {
4062                session = openSession();
4063
4064                Query q = session.createQuery(sql);
4065
4066                QueryPos qPos = QueryPos.getInstance(q);
4067
4068                qPos.add(nodeId);
4069
4070                if (redirectTitle != null) {
4071                    qPos.add(redirectTitle);
4072                }
4073
4074                count = (Long)q.uniqueResult();
4075            }
4076            catch (Exception e) {
4077                throw processException(e);
4078            }
4079            finally {
4080                if (count == null) {
4081                    count = Long.valueOf(0);
4082                }
4083
4084                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_N_R, finderArgs,
4085                    count);
4086
4087                closeSession(session);
4088            }
4089        }
4090
4091        return count.intValue();
4092    }
4093
4094    public int countByN_T_V(long nodeId, String title, double version)
4095        throws SystemException {
4096        Object[] finderArgs = new Object[] { nodeId, title, version };
4097
4098        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_N_T_V,
4099                finderArgs, this);
4100
4101        if (count == null) {
4102            StringBundler query = new StringBundler(4);
4103
4104            query.append(_SQL_COUNT_WIKIPAGE_WHERE);
4105
4106            query.append(_FINDER_COLUMN_N_T_V_NODEID_2);
4107
4108            if (title == null) {
4109                query.append(_FINDER_COLUMN_N_T_V_TITLE_1);
4110            }
4111            else {
4112                if (title.equals(StringPool.BLANK)) {
4113                    query.append(_FINDER_COLUMN_N_T_V_TITLE_3);
4114                }
4115                else {
4116                    query.append(_FINDER_COLUMN_N_T_V_TITLE_2);
4117                }
4118            }
4119
4120            query.append(_FINDER_COLUMN_N_T_V_VERSION_2);
4121
4122            String sql = query.toString();
4123
4124            Session session = null;
4125
4126            try {
4127                session = openSession();
4128
4129                Query q = session.createQuery(sql);
4130
4131                QueryPos qPos = QueryPos.getInstance(q);
4132
4133                qPos.add(nodeId);
4134
4135                if (title != null) {
4136                    qPos.add(title);
4137                }
4138
4139                qPos.add(version);
4140
4141                count = (Long)q.uniqueResult();
4142            }
4143            catch (Exception e) {
4144                throw processException(e);
4145            }
4146            finally {
4147                if (count == null) {
4148                    count = Long.valueOf(0);
4149                }
4150
4151                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_N_T_V,
4152                    finderArgs, count);
4153
4154                closeSession(session);
4155            }
4156        }
4157
4158        return count.intValue();
4159    }
4160
4161    public int countByN_T_H(long nodeId, String title, boolean head)
4162        throws SystemException {
4163        Object[] finderArgs = new Object[] { nodeId, title, head };
4164
4165        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_N_T_H,
4166                finderArgs, this);
4167
4168        if (count == null) {
4169            StringBundler query = new StringBundler(4);
4170
4171            query.append(_SQL_COUNT_WIKIPAGE_WHERE);
4172
4173            query.append(_FINDER_COLUMN_N_T_H_NODEID_2);
4174
4175            if (title == null) {
4176                query.append(_FINDER_COLUMN_N_T_H_TITLE_1);
4177            }
4178            else {
4179                if (title.equals(StringPool.BLANK)) {
4180                    query.append(_FINDER_COLUMN_N_T_H_TITLE_3);
4181                }
4182                else {
4183                    query.append(_FINDER_COLUMN_N_T_H_TITLE_2);
4184                }
4185            }
4186
4187            query.append(_FINDER_COLUMN_N_T_H_HEAD_2);
4188
4189            String sql = query.toString();
4190
4191            Session session = null;
4192
4193            try {
4194                session = openSession();
4195
4196                Query q = session.createQuery(sql);
4197
4198                QueryPos qPos = QueryPos.getInstance(q);
4199
4200                qPos.add(nodeId);
4201
4202                if (title != null) {
4203                    qPos.add(title);
4204                }
4205
4206                qPos.add(head);
4207
4208                count = (Long)q.uniqueResult();
4209            }
4210            catch (Exception e) {
4211                throw processException(e);
4212            }
4213            finally {
4214                if (count == null) {
4215                    count = Long.valueOf(0);
4216                }
4217
4218                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_N_T_H,
4219                    finderArgs, count);
4220
4221                closeSession(session);
4222            }
4223        }
4224
4225        return count.intValue();
4226    }
4227
4228    public int countByN_H_P(long nodeId, boolean head, String parentTitle)
4229        throws SystemException {
4230        Object[] finderArgs = new Object[] { nodeId, head, parentTitle };
4231
4232        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_N_H_P,
4233                finderArgs, this);
4234
4235        if (count == null) {
4236            StringBundler query = new StringBundler(4);
4237
4238            query.append(_SQL_COUNT_WIKIPAGE_WHERE);
4239
4240            query.append(_FINDER_COLUMN_N_H_P_NODEID_2);
4241
4242            query.append(_FINDER_COLUMN_N_H_P_HEAD_2);
4243
4244            if (parentTitle == null) {
4245                query.append(_FINDER_COLUMN_N_H_P_PARENTTITLE_1);
4246            }
4247            else {
4248                if (parentTitle.equals(StringPool.BLANK)) {
4249                    query.append(_FINDER_COLUMN_N_H_P_PARENTTITLE_3);
4250                }
4251                else {
4252                    query.append(_FINDER_COLUMN_N_H_P_PARENTTITLE_2);
4253                }
4254            }
4255
4256            String sql = query.toString();
4257
4258            Session session = null;
4259
4260            try {
4261                session = openSession();
4262
4263                Query q = session.createQuery(sql);
4264
4265                QueryPos qPos = QueryPos.getInstance(q);
4266
4267                qPos.add(nodeId);
4268
4269                qPos.add(head);
4270
4271                if (parentTitle != null) {
4272                    qPos.add(parentTitle);
4273                }
4274
4275                count = (Long)q.uniqueResult();
4276            }
4277            catch (Exception e) {
4278                throw processException(e);
4279            }
4280            finally {
4281                if (count == null) {
4282                    count = Long.valueOf(0);
4283                }
4284
4285                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_N_H_P,
4286                    finderArgs, count);
4287
4288                closeSession(session);
4289            }
4290        }
4291
4292        return count.intValue();
4293    }
4294
4295    public int countAll() throws SystemException {
4296        Object[] finderArgs = new Object[0];
4297
4298        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
4299                finderArgs, this);
4300
4301        if (count == null) {
4302            Session session = null;
4303
4304            try {
4305                session = openSession();
4306
4307                Query q = session.createQuery(_SQL_COUNT_WIKIPAGE);
4308
4309                count = (Long)q.uniqueResult();
4310            }
4311            catch (Exception e) {
4312                throw processException(e);
4313            }
4314            finally {
4315                if (count == null) {
4316                    count = Long.valueOf(0);
4317                }
4318
4319                FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
4320                    count);
4321
4322                closeSession(session);
4323            }
4324        }
4325
4326        return count.intValue();
4327    }
4328
4329    public void afterPropertiesSet() {
4330        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
4331                    com.liferay.portal.util.PropsUtil.get(
4332                        "value.object.listener.com.liferay.portlet.wiki.model.WikiPage")));
4333
4334        if (listenerClassNames.length > 0) {
4335            try {
4336                List<ModelListener<WikiPage>> listenersList = new ArrayList<ModelListener<WikiPage>>();
4337
4338                for (String listenerClassName : listenerClassNames) {
4339                    listenersList.add((ModelListener<WikiPage>)InstanceFactory.newInstance(
4340                            listenerClassName));
4341                }
4342
4343                listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
4344            }
4345            catch (Exception e) {
4346                _log.error(e);
4347            }
4348        }
4349    }
4350
4351    public void destroy() {
4352        EntityCacheUtil.removeCache(WikiPageImpl.class.getName());
4353        FinderCacheUtil.removeCache(FINDER_CLASS_NAME_ENTITY);
4354        FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST);
4355    }
4356
4357    @BeanReference(type = WikiNodePersistence.class)
4358    protected WikiNodePersistence wikiNodePersistence;
4359    @BeanReference(type = WikiPagePersistence.class)
4360    protected WikiPagePersistence wikiPagePersistence;
4361    @BeanReference(type = WikiPageResourcePersistence.class)
4362    protected WikiPageResourcePersistence wikiPageResourcePersistence;
4363    @BeanReference(type = CompanyPersistence.class)
4364    protected CompanyPersistence companyPersistence;
4365    @BeanReference(type = GroupPersistence.class)
4366    protected GroupPersistence groupPersistence;
4367    @BeanReference(type = PortletPreferencesPersistence.class)
4368    protected PortletPreferencesPersistence portletPreferencesPersistence;
4369    @BeanReference(type = ResourcePersistence.class)
4370    protected ResourcePersistence resourcePersistence;
4371    @BeanReference(type = SubscriptionPersistence.class)
4372    protected SubscriptionPersistence subscriptionPersistence;
4373    @BeanReference(type = UserPersistence.class)
4374    protected UserPersistence userPersistence;
4375    @BeanReference(type = MBMessagePersistence.class)
4376    protected MBMessagePersistence mbMessagePersistence;
4377    @BeanReference(type = SocialActivityPersistence.class)
4378    protected SocialActivityPersistence socialActivityPersistence;
4379    @BeanReference(type = TagsAssetPersistence.class)
4380    protected TagsAssetPersistence tagsAssetPersistence;
4381    @BeanReference(type = TagsEntryPersistence.class)
4382    protected TagsEntryPersistence tagsEntryPersistence;
4383    private static final String _SQL_SELECT_WIKIPAGE = "SELECT wikiPage FROM WikiPage wikiPage";
4384    private static final String _SQL_SELECT_WIKIPAGE_WHERE = "SELECT wikiPage FROM WikiPage wikiPage WHERE ";
4385    private static final String _SQL_COUNT_WIKIPAGE = "SELECT COUNT(wikiPage) FROM WikiPage wikiPage";
4386    private static final String _SQL_COUNT_WIKIPAGE_WHERE = "SELECT COUNT(wikiPage) FROM WikiPage wikiPage WHERE ";
4387    private static final String _FINDER_COLUMN_UUID_UUID_1 = "wikiPage.uuid IS NULL";
4388    private static final String _FINDER_COLUMN_UUID_UUID_2 = "wikiPage.uuid = ?";
4389    private static final String _FINDER_COLUMN_UUID_UUID_3 = "(wikiPage.uuid IS NULL OR wikiPage.uuid = ?)";
4390    private static final String _FINDER_COLUMN_UUID_G_UUID_1 = "wikiPage.uuid IS NULL AND ";
4391    private static final String _FINDER_COLUMN_UUID_G_UUID_2 = "wikiPage.uuid = ? AND ";
4392    private static final String _FINDER_COLUMN_UUID_G_UUID_3 = "(wikiPage.uuid IS NULL OR wikiPage.uuid = ?) AND ";
4393    private static final String _FINDER_COLUMN_UUID_G_GROUPID_2 = "wikiPage.groupId = ?";
4394    private static final String _FINDER_COLUMN_NODEID_NODEID_2 = "wikiPage.nodeId = ?";
4395    private static final String _FINDER_COLUMN_FORMAT_FORMAT_1 = "wikiPage.format IS NULL";
4396    private static final String _FINDER_COLUMN_FORMAT_FORMAT_2 = "wikiPage.format = ?";
4397    private static final String _FINDER_COLUMN_FORMAT_FORMAT_3 = "(wikiPage.format IS NULL OR wikiPage.format = ?)";
4398    private static final String _FINDER_COLUMN_N_T_NODEID_2 = "wikiPage.nodeId = ? AND ";
4399    private static final String _FINDER_COLUMN_N_T_TITLE_1 = "wikiPage.title IS NULL";
4400    private static final String _FINDER_COLUMN_N_T_TITLE_2 = "lower(wikiPage.title) = lower(?)";
4401    private static final String _FINDER_COLUMN_N_T_TITLE_3 = "(wikiPage.title IS NULL OR lower(wikiPage.title) = lower(?))";
4402    private static final String _FINDER_COLUMN_N_H_NODEID_2 = "wikiPage.nodeId = ? AND ";
4403    private static final String _FINDER_COLUMN_N_H_HEAD_2 = "wikiPage.head = ?";
4404    private static final String _FINDER_COLUMN_N_P_NODEID_2 = "wikiPage.nodeId = ? AND ";
4405    private static final String _FINDER_COLUMN_N_P_PARENTTITLE_1 = "wikiPage.parentTitle IS NULL";
4406    private static final String _FINDER_COLUMN_N_P_PARENTTITLE_2 = "lower(wikiPage.parentTitle) = lower(?)";
4407    private static final String _FINDER_COLUMN_N_P_PARENTTITLE_3 = "(wikiPage.parentTitle IS NULL OR lower(wikiPage.parentTitle) = lower(?))";
4408    private static final String _FINDER_COLUMN_N_R_NODEID_2 = "wikiPage.nodeId = ? AND ";
4409    private static final String _FINDER_COLUMN_N_R_REDIRECTTITLE_1 = "wikiPage.redirectTitle IS NULL";
4410    private static final String _FINDER_COLUMN_N_R_REDIRECTTITLE_2 = "lower(wikiPage.redirectTitle) = lower(?)";
4411    private static final String _FINDER_COLUMN_N_R_REDIRECTTITLE_3 = "(wikiPage.redirectTitle IS NULL OR lower(wikiPage.redirectTitle) = lower(?))";
4412    private static final String _FINDER_COLUMN_N_T_V_NODEID_2 = "wikiPage.nodeId = ? AND ";
4413    private static final String _FINDER_COLUMN_N_T_V_TITLE_1 = "wikiPage.title IS NULL AND ";
4414    private static final String _FINDER_COLUMN_N_T_V_TITLE_2 = "lower(wikiPage.title) = lower(?) AND ";
4415    private static final String _FINDER_COLUMN_N_T_V_TITLE_3 = "(wikiPage.title IS NULL OR lower(wikiPage.title) = lower(?)) AND ";
4416    private static final String _FINDER_COLUMN_N_T_V_VERSION_2 = "wikiPage.version = ?";
4417    private static final String _FINDER_COLUMN_N_T_H_NODEID_2 = "wikiPage.nodeId = ? AND ";
4418    private static final String _FINDER_COLUMN_N_T_H_TITLE_1 = "wikiPage.title IS NULL AND ";
4419    private static final String _FINDER_COLUMN_N_T_H_TITLE_2 = "lower(wikiPage.title) = lower(?) AND ";
4420    private static final String _FINDER_COLUMN_N_T_H_TITLE_3 = "(wikiPage.title IS NULL OR lower(wikiPage.title) = lower(?)) AND ";
4421    private static final String _FINDER_COLUMN_N_T_H_HEAD_2 = "wikiPage.head = ?";
4422    private static final String _FINDER_COLUMN_N_H_P_NODEID_2 = "wikiPage.nodeId = ? AND ";
4423    private static final String _FINDER_COLUMN_N_H_P_HEAD_2 = "wikiPage.head = ? AND ";
4424    private static final String _FINDER_COLUMN_N_H_P_PARENTTITLE_1 = "wikiPage.parentTitle IS NULL";
4425    private static final String _FINDER_COLUMN_N_H_P_PARENTTITLE_2 = "lower(wikiPage.parentTitle) = lower(?)";
4426    private static final String _FINDER_COLUMN_N_H_P_PARENTTITLE_3 = "(wikiPage.parentTitle IS NULL OR lower(wikiPage.parentTitle) = lower(?))";
4427    private static final String _ORDER_BY_ENTITY_ALIAS = "wikiPage.";
4428    private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No WikiPage exists with the primary key ";
4429    private static final String _NO_SUCH_ENTITY_WITH_KEY = "No WikiPage exists with the key {";
4430    private static Log _log = LogFactoryUtil.getLog(WikiPagePersistenceImpl.class);
4431}