001    /**
002     * Copyright (c) 2000-2012 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.wiki.service.persistence;
016    
017    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
018    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
019    import com.liferay.portal.kernel.exception.SystemException;
020    import com.liferay.portal.kernel.util.OrderByComparator;
021    import com.liferay.portal.kernel.util.ReferenceRegistry;
022    import com.liferay.portal.service.ServiceContext;
023    
024    import com.liferay.portlet.wiki.model.WikiPage;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the wiki page service. This utility wraps {@link WikiPagePersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
030     *
031     * <p>
032     * Caching information and settings can be found in <code>portal.properties</code>
033     * </p>
034     *
035     * @author Brian Wing Shun Chan
036     * @see WikiPagePersistence
037     * @see WikiPagePersistenceImpl
038     * @generated
039     */
040    public class WikiPageUtil {
041            /*
042             * NOTE FOR DEVELOPERS:
043             *
044             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
045             */
046    
047            /**
048             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
049             */
050            public static void clearCache() {
051                    getPersistence().clearCache();
052            }
053    
054            /**
055             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
056             */
057            public static void clearCache(WikiPage wikiPage) {
058                    getPersistence().clearCache(wikiPage);
059            }
060    
061            /**
062             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
063             */
064            public long countWithDynamicQuery(DynamicQuery dynamicQuery)
065                    throws SystemException {
066                    return getPersistence().countWithDynamicQuery(dynamicQuery);
067            }
068    
069            /**
070             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
071             */
072            public static List<WikiPage> findWithDynamicQuery(DynamicQuery dynamicQuery)
073                    throws SystemException {
074                    return getPersistence().findWithDynamicQuery(dynamicQuery);
075            }
076    
077            /**
078             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
079             */
080            public static List<WikiPage> findWithDynamicQuery(
081                    DynamicQuery dynamicQuery, int start, int end)
082                    throws SystemException {
083                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
084            }
085    
086            /**
087             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
088             */
089            public static List<WikiPage> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator orderByComparator) throws SystemException {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)
099             */
100            public static WikiPage update(WikiPage wikiPage, boolean merge)
101                    throws SystemException {
102                    return getPersistence().update(wikiPage, merge);
103            }
104    
105            /**
106             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext)
107             */
108            public static WikiPage update(WikiPage wikiPage, boolean merge,
109                    ServiceContext serviceContext) throws SystemException {
110                    return getPersistence().update(wikiPage, merge, serviceContext);
111            }
112    
113            /**
114            * Caches the wiki page in the entity cache if it is enabled.
115            *
116            * @param wikiPage the wiki page
117            */
118            public static void cacheResult(
119                    com.liferay.portlet.wiki.model.WikiPage wikiPage) {
120                    getPersistence().cacheResult(wikiPage);
121            }
122    
123            /**
124            * Caches the wiki pages in the entity cache if it is enabled.
125            *
126            * @param wikiPages the wiki pages
127            */
128            public static void cacheResult(
129                    java.util.List<com.liferay.portlet.wiki.model.WikiPage> wikiPages) {
130                    getPersistence().cacheResult(wikiPages);
131            }
132    
133            /**
134            * Creates a new wiki page with the primary key. Does not add the wiki page to the database.
135            *
136            * @param pageId the primary key for the new wiki page
137            * @return the new wiki page
138            */
139            public static com.liferay.portlet.wiki.model.WikiPage create(long pageId) {
140                    return getPersistence().create(pageId);
141            }
142    
143            /**
144            * Removes the wiki page with the primary key from the database. Also notifies the appropriate model listeners.
145            *
146            * @param pageId the primary key of the wiki page
147            * @return the wiki page that was removed
148            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
149            * @throws SystemException if a system exception occurred
150            */
151            public static com.liferay.portlet.wiki.model.WikiPage remove(long pageId)
152                    throws com.liferay.portal.kernel.exception.SystemException,
153                            com.liferay.portlet.wiki.NoSuchPageException {
154                    return getPersistence().remove(pageId);
155            }
156    
157            public static com.liferay.portlet.wiki.model.WikiPage updateImpl(
158                    com.liferay.portlet.wiki.model.WikiPage wikiPage, boolean merge)
159                    throws com.liferay.portal.kernel.exception.SystemException {
160                    return getPersistence().updateImpl(wikiPage, merge);
161            }
162    
163            /**
164            * Returns the wiki page with the primary key or throws a {@link com.liferay.portlet.wiki.NoSuchPageException} if it could not be found.
165            *
166            * @param pageId the primary key of the wiki page
167            * @return the wiki page
168            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
169            * @throws SystemException if a system exception occurred
170            */
171            public static com.liferay.portlet.wiki.model.WikiPage findByPrimaryKey(
172                    long pageId)
173                    throws com.liferay.portal.kernel.exception.SystemException,
174                            com.liferay.portlet.wiki.NoSuchPageException {
175                    return getPersistence().findByPrimaryKey(pageId);
176            }
177    
178            /**
179            * Returns the wiki page with the primary key or returns <code>null</code> if it could not be found.
180            *
181            * @param pageId the primary key of the wiki page
182            * @return the wiki page, or <code>null</code> if a wiki page with the primary key could not be found
183            * @throws SystemException if a system exception occurred
184            */
185            public static com.liferay.portlet.wiki.model.WikiPage fetchByPrimaryKey(
186                    long pageId) throws com.liferay.portal.kernel.exception.SystemException {
187                    return getPersistence().fetchByPrimaryKey(pageId);
188            }
189    
190            /**
191            * Returns all the wiki pages where uuid = &#63;.
192            *
193            * @param uuid the uuid
194            * @return the matching wiki pages
195            * @throws SystemException if a system exception occurred
196            */
197            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByUuid(
198                    java.lang.String uuid)
199                    throws com.liferay.portal.kernel.exception.SystemException {
200                    return getPersistence().findByUuid(uuid);
201            }
202    
203            /**
204            * Returns a range of all the wiki pages where uuid = &#63;.
205            *
206            * <p>
207            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
208            * </p>
209            *
210            * @param uuid the uuid
211            * @param start the lower bound of the range of wiki pages
212            * @param end the upper bound of the range of wiki pages (not inclusive)
213            * @return the range of matching wiki pages
214            * @throws SystemException if a system exception occurred
215            */
216            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByUuid(
217                    java.lang.String uuid, int start, int end)
218                    throws com.liferay.portal.kernel.exception.SystemException {
219                    return getPersistence().findByUuid(uuid, start, end);
220            }
221    
222            /**
223            * Returns an ordered range of all the wiki pages where uuid = &#63;.
224            *
225            * <p>
226            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
227            * </p>
228            *
229            * @param uuid the uuid
230            * @param start the lower bound of the range of wiki pages
231            * @param end the upper bound of the range of wiki pages (not inclusive)
232            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
233            * @return the ordered range of matching wiki pages
234            * @throws SystemException if a system exception occurred
235            */
236            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByUuid(
237                    java.lang.String uuid, int start, int end,
238                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
239                    throws com.liferay.portal.kernel.exception.SystemException {
240                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
241            }
242    
243            /**
244            * Returns the first wiki page in the ordered set where uuid = &#63;.
245            *
246            * <p>
247            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
248            * </p>
249            *
250            * @param uuid the uuid
251            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
252            * @return the first matching wiki page
253            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
254            * @throws SystemException if a system exception occurred
255            */
256            public static com.liferay.portlet.wiki.model.WikiPage findByUuid_First(
257                    java.lang.String uuid,
258                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
259                    throws com.liferay.portal.kernel.exception.SystemException,
260                            com.liferay.portlet.wiki.NoSuchPageException {
261                    return getPersistence().findByUuid_First(uuid, orderByComparator);
262            }
263    
264            /**
265            * Returns the last wiki page in the ordered set where uuid = &#63;.
266            *
267            * <p>
268            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
269            * </p>
270            *
271            * @param uuid the uuid
272            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
273            * @return the last matching wiki page
274            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
275            * @throws SystemException if a system exception occurred
276            */
277            public static com.liferay.portlet.wiki.model.WikiPage findByUuid_Last(
278                    java.lang.String uuid,
279                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
280                    throws com.liferay.portal.kernel.exception.SystemException,
281                            com.liferay.portlet.wiki.NoSuchPageException {
282                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
283            }
284    
285            /**
286            * Returns the wiki pages before and after the current wiki page in the ordered set where uuid = &#63;.
287            *
288            * <p>
289            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
290            * </p>
291            *
292            * @param pageId the primary key of the current wiki page
293            * @param uuid the uuid
294            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
295            * @return the previous, current, and next wiki page
296            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
297            * @throws SystemException if a system exception occurred
298            */
299            public static com.liferay.portlet.wiki.model.WikiPage[] findByUuid_PrevAndNext(
300                    long pageId, java.lang.String uuid,
301                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
302                    throws com.liferay.portal.kernel.exception.SystemException,
303                            com.liferay.portlet.wiki.NoSuchPageException {
304                    return getPersistence()
305                                       .findByUuid_PrevAndNext(pageId, uuid, orderByComparator);
306            }
307    
308            /**
309            * Returns the wiki page where uuid = &#63; and groupId = &#63; or throws a {@link com.liferay.portlet.wiki.NoSuchPageException} if it could not be found.
310            *
311            * @param uuid the uuid
312            * @param groupId the group ID
313            * @return the matching wiki page
314            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
315            * @throws SystemException if a system exception occurred
316            */
317            public static com.liferay.portlet.wiki.model.WikiPage findByUUID_G(
318                    java.lang.String uuid, long groupId)
319                    throws com.liferay.portal.kernel.exception.SystemException,
320                            com.liferay.portlet.wiki.NoSuchPageException {
321                    return getPersistence().findByUUID_G(uuid, groupId);
322            }
323    
324            /**
325            * Returns the wiki page where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
326            *
327            * @param uuid the uuid
328            * @param groupId the group ID
329            * @return the matching wiki page, or <code>null</code> if a matching wiki page could not be found
330            * @throws SystemException if a system exception occurred
331            */
332            public static com.liferay.portlet.wiki.model.WikiPage fetchByUUID_G(
333                    java.lang.String uuid, long groupId)
334                    throws com.liferay.portal.kernel.exception.SystemException {
335                    return getPersistence().fetchByUUID_G(uuid, groupId);
336            }
337    
338            /**
339            * Returns the wiki page where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
340            *
341            * @param uuid the uuid
342            * @param groupId the group ID
343            * @param retrieveFromCache whether to use the finder cache
344            * @return the matching wiki page, or <code>null</code> if a matching wiki page could not be found
345            * @throws SystemException if a system exception occurred
346            */
347            public static com.liferay.portlet.wiki.model.WikiPage fetchByUUID_G(
348                    java.lang.String uuid, long groupId, boolean retrieveFromCache)
349                    throws com.liferay.portal.kernel.exception.SystemException {
350                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
351            }
352    
353            /**
354            * Returns all the wiki pages where nodeId = &#63;.
355            *
356            * @param nodeId the node ID
357            * @return the matching wiki pages
358            * @throws SystemException if a system exception occurred
359            */
360            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByNodeId(
361                    long nodeId) throws com.liferay.portal.kernel.exception.SystemException {
362                    return getPersistence().findByNodeId(nodeId);
363            }
364    
365            /**
366            * Returns a range of all the wiki pages where nodeId = &#63;.
367            *
368            * <p>
369            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
370            * </p>
371            *
372            * @param nodeId the node ID
373            * @param start the lower bound of the range of wiki pages
374            * @param end the upper bound of the range of wiki pages (not inclusive)
375            * @return the range of matching wiki pages
376            * @throws SystemException if a system exception occurred
377            */
378            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByNodeId(
379                    long nodeId, int start, int end)
380                    throws com.liferay.portal.kernel.exception.SystemException {
381                    return getPersistence().findByNodeId(nodeId, start, end);
382            }
383    
384            /**
385            * Returns an ordered range of all the wiki pages where nodeId = &#63;.
386            *
387            * <p>
388            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
389            * </p>
390            *
391            * @param nodeId the node ID
392            * @param start the lower bound of the range of wiki pages
393            * @param end the upper bound of the range of wiki pages (not inclusive)
394            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
395            * @return the ordered range of matching wiki pages
396            * @throws SystemException if a system exception occurred
397            */
398            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByNodeId(
399                    long nodeId, int start, int end,
400                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
401                    throws com.liferay.portal.kernel.exception.SystemException {
402                    return getPersistence()
403                                       .findByNodeId(nodeId, start, end, orderByComparator);
404            }
405    
406            /**
407            * Returns the first wiki page in the ordered set where nodeId = &#63;.
408            *
409            * <p>
410            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
411            * </p>
412            *
413            * @param nodeId the node ID
414            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
415            * @return the first matching wiki page
416            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
417            * @throws SystemException if a system exception occurred
418            */
419            public static com.liferay.portlet.wiki.model.WikiPage findByNodeId_First(
420                    long nodeId,
421                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
422                    throws com.liferay.portal.kernel.exception.SystemException,
423                            com.liferay.portlet.wiki.NoSuchPageException {
424                    return getPersistence().findByNodeId_First(nodeId, orderByComparator);
425            }
426    
427            /**
428            * Returns the last wiki page in the ordered set where nodeId = &#63;.
429            *
430            * <p>
431            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
432            * </p>
433            *
434            * @param nodeId the node ID
435            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
436            * @return the last matching wiki page
437            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
438            * @throws SystemException if a system exception occurred
439            */
440            public static com.liferay.portlet.wiki.model.WikiPage findByNodeId_Last(
441                    long nodeId,
442                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
443                    throws com.liferay.portal.kernel.exception.SystemException,
444                            com.liferay.portlet.wiki.NoSuchPageException {
445                    return getPersistence().findByNodeId_Last(nodeId, orderByComparator);
446            }
447    
448            /**
449            * Returns the wiki pages before and after the current wiki page in the ordered set where nodeId = &#63;.
450            *
451            * <p>
452            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
453            * </p>
454            *
455            * @param pageId the primary key of the current wiki page
456            * @param nodeId the node ID
457            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
458            * @return the previous, current, and next wiki page
459            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
460            * @throws SystemException if a system exception occurred
461            */
462            public static com.liferay.portlet.wiki.model.WikiPage[] findByNodeId_PrevAndNext(
463                    long pageId, long nodeId,
464                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
465                    throws com.liferay.portal.kernel.exception.SystemException,
466                            com.liferay.portlet.wiki.NoSuchPageException {
467                    return getPersistence()
468                                       .findByNodeId_PrevAndNext(pageId, nodeId, orderByComparator);
469            }
470    
471            /**
472            * Returns all the wiki pages where format = &#63;.
473            *
474            * @param format the format
475            * @return the matching wiki pages
476            * @throws SystemException if a system exception occurred
477            */
478            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByFormat(
479                    java.lang.String format)
480                    throws com.liferay.portal.kernel.exception.SystemException {
481                    return getPersistence().findByFormat(format);
482            }
483    
484            /**
485            * Returns a range of all the wiki pages where format = &#63;.
486            *
487            * <p>
488            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
489            * </p>
490            *
491            * @param format the format
492            * @param start the lower bound of the range of wiki pages
493            * @param end the upper bound of the range of wiki pages (not inclusive)
494            * @return the range of matching wiki pages
495            * @throws SystemException if a system exception occurred
496            */
497            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByFormat(
498                    java.lang.String format, int start, int end)
499                    throws com.liferay.portal.kernel.exception.SystemException {
500                    return getPersistence().findByFormat(format, start, end);
501            }
502    
503            /**
504            * Returns an ordered range of all the wiki pages where format = &#63;.
505            *
506            * <p>
507            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
508            * </p>
509            *
510            * @param format the format
511            * @param start the lower bound of the range of wiki pages
512            * @param end the upper bound of the range of wiki pages (not inclusive)
513            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
514            * @return the ordered range of matching wiki pages
515            * @throws SystemException if a system exception occurred
516            */
517            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByFormat(
518                    java.lang.String format, int start, int end,
519                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
520                    throws com.liferay.portal.kernel.exception.SystemException {
521                    return getPersistence()
522                                       .findByFormat(format, start, end, orderByComparator);
523            }
524    
525            /**
526            * Returns the first wiki page in the ordered set where format = &#63;.
527            *
528            * <p>
529            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
530            * </p>
531            *
532            * @param format the format
533            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
534            * @return the first matching wiki page
535            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
536            * @throws SystemException if a system exception occurred
537            */
538            public static com.liferay.portlet.wiki.model.WikiPage findByFormat_First(
539                    java.lang.String format,
540                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
541                    throws com.liferay.portal.kernel.exception.SystemException,
542                            com.liferay.portlet.wiki.NoSuchPageException {
543                    return getPersistence().findByFormat_First(format, orderByComparator);
544            }
545    
546            /**
547            * Returns the last wiki page in the ordered set where format = &#63;.
548            *
549            * <p>
550            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
551            * </p>
552            *
553            * @param format the format
554            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
555            * @return the last matching wiki page
556            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
557            * @throws SystemException if a system exception occurred
558            */
559            public static com.liferay.portlet.wiki.model.WikiPage findByFormat_Last(
560                    java.lang.String format,
561                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
562                    throws com.liferay.portal.kernel.exception.SystemException,
563                            com.liferay.portlet.wiki.NoSuchPageException {
564                    return getPersistence().findByFormat_Last(format, orderByComparator);
565            }
566    
567            /**
568            * Returns the wiki pages before and after the current wiki page in the ordered set where format = &#63;.
569            *
570            * <p>
571            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
572            * </p>
573            *
574            * @param pageId the primary key of the current wiki page
575            * @param format the format
576            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
577            * @return the previous, current, and next wiki page
578            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
579            * @throws SystemException if a system exception occurred
580            */
581            public static com.liferay.portlet.wiki.model.WikiPage[] findByFormat_PrevAndNext(
582                    long pageId, java.lang.String format,
583                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
584                    throws com.liferay.portal.kernel.exception.SystemException,
585                            com.liferay.portlet.wiki.NoSuchPageException {
586                    return getPersistence()
587                                       .findByFormat_PrevAndNext(pageId, format, orderByComparator);
588            }
589    
590            /**
591            * Returns all the wiki pages where resourcePrimKey = &#63; and nodeId = &#63;.
592            *
593            * @param resourcePrimKey the resource prim key
594            * @param nodeId the node ID
595            * @return the matching wiki pages
596            * @throws SystemException if a system exception occurred
597            */
598            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByR_N(
599                    long resourcePrimKey, long nodeId)
600                    throws com.liferay.portal.kernel.exception.SystemException {
601                    return getPersistence().findByR_N(resourcePrimKey, nodeId);
602            }
603    
604            /**
605            * Returns a range of all the wiki pages where resourcePrimKey = &#63; and nodeId = &#63;.
606            *
607            * <p>
608            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
609            * </p>
610            *
611            * @param resourcePrimKey the resource prim key
612            * @param nodeId the node ID
613            * @param start the lower bound of the range of wiki pages
614            * @param end the upper bound of the range of wiki pages (not inclusive)
615            * @return the range of matching wiki pages
616            * @throws SystemException if a system exception occurred
617            */
618            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByR_N(
619                    long resourcePrimKey, long nodeId, int start, int end)
620                    throws com.liferay.portal.kernel.exception.SystemException {
621                    return getPersistence().findByR_N(resourcePrimKey, nodeId, start, end);
622            }
623    
624            /**
625            * Returns an ordered range of all the wiki pages where resourcePrimKey = &#63; and nodeId = &#63;.
626            *
627            * <p>
628            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
629            * </p>
630            *
631            * @param resourcePrimKey the resource prim key
632            * @param nodeId the node ID
633            * @param start the lower bound of the range of wiki pages
634            * @param end the upper bound of the range of wiki pages (not inclusive)
635            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
636            * @return the ordered range of matching wiki pages
637            * @throws SystemException if a system exception occurred
638            */
639            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByR_N(
640                    long resourcePrimKey, long nodeId, int start, int end,
641                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
642                    throws com.liferay.portal.kernel.exception.SystemException {
643                    return getPersistence()
644                                       .findByR_N(resourcePrimKey, nodeId, start, end,
645                            orderByComparator);
646            }
647    
648            /**
649            * Returns the first wiki page in the ordered set where resourcePrimKey = &#63; and nodeId = &#63;.
650            *
651            * <p>
652            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
653            * </p>
654            *
655            * @param resourcePrimKey the resource prim key
656            * @param nodeId the node ID
657            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
658            * @return the first matching wiki page
659            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
660            * @throws SystemException if a system exception occurred
661            */
662            public static com.liferay.portlet.wiki.model.WikiPage findByR_N_First(
663                    long resourcePrimKey, long nodeId,
664                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
665                    throws com.liferay.portal.kernel.exception.SystemException,
666                            com.liferay.portlet.wiki.NoSuchPageException {
667                    return getPersistence()
668                                       .findByR_N_First(resourcePrimKey, nodeId, orderByComparator);
669            }
670    
671            /**
672            * Returns the last wiki page in the ordered set where resourcePrimKey = &#63; and nodeId = &#63;.
673            *
674            * <p>
675            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
676            * </p>
677            *
678            * @param resourcePrimKey the resource prim key
679            * @param nodeId the node ID
680            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
681            * @return the last matching wiki page
682            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
683            * @throws SystemException if a system exception occurred
684            */
685            public static com.liferay.portlet.wiki.model.WikiPage findByR_N_Last(
686                    long resourcePrimKey, long nodeId,
687                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
688                    throws com.liferay.portal.kernel.exception.SystemException,
689                            com.liferay.portlet.wiki.NoSuchPageException {
690                    return getPersistence()
691                                       .findByR_N_Last(resourcePrimKey, nodeId, orderByComparator);
692            }
693    
694            /**
695            * Returns the wiki pages before and after the current wiki page in the ordered set where resourcePrimKey = &#63; and nodeId = &#63;.
696            *
697            * <p>
698            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
699            * </p>
700            *
701            * @param pageId the primary key of the current wiki page
702            * @param resourcePrimKey the resource prim key
703            * @param nodeId the node ID
704            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
705            * @return the previous, current, and next wiki page
706            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
707            * @throws SystemException if a system exception occurred
708            */
709            public static com.liferay.portlet.wiki.model.WikiPage[] findByR_N_PrevAndNext(
710                    long pageId, long resourcePrimKey, long nodeId,
711                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
712                    throws com.liferay.portal.kernel.exception.SystemException,
713                            com.liferay.portlet.wiki.NoSuchPageException {
714                    return getPersistence()
715                                       .findByR_N_PrevAndNext(pageId, resourcePrimKey, nodeId,
716                            orderByComparator);
717            }
718    
719            /**
720            * Returns all the wiki pages where nodeId = &#63; and title = &#63;.
721            *
722            * @param nodeId the node ID
723            * @param title the title
724            * @return the matching wiki pages
725            * @throws SystemException if a system exception occurred
726            */
727            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_T(
728                    long nodeId, java.lang.String title)
729                    throws com.liferay.portal.kernel.exception.SystemException {
730                    return getPersistence().findByN_T(nodeId, title);
731            }
732    
733            /**
734            * Returns a range of all the wiki pages where nodeId = &#63; and title = &#63;.
735            *
736            * <p>
737            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
738            * </p>
739            *
740            * @param nodeId the node ID
741            * @param title the title
742            * @param start the lower bound of the range of wiki pages
743            * @param end the upper bound of the range of wiki pages (not inclusive)
744            * @return the range of matching wiki pages
745            * @throws SystemException if a system exception occurred
746            */
747            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_T(
748                    long nodeId, java.lang.String title, int start, int end)
749                    throws com.liferay.portal.kernel.exception.SystemException {
750                    return getPersistence().findByN_T(nodeId, title, start, end);
751            }
752    
753            /**
754            * Returns an ordered range of all the wiki pages where nodeId = &#63; and title = &#63;.
755            *
756            * <p>
757            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
758            * </p>
759            *
760            * @param nodeId the node ID
761            * @param title the title
762            * @param start the lower bound of the range of wiki pages
763            * @param end the upper bound of the range of wiki pages (not inclusive)
764            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
765            * @return the ordered range of matching wiki pages
766            * @throws SystemException if a system exception occurred
767            */
768            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_T(
769                    long nodeId, java.lang.String title, int start, int end,
770                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
771                    throws com.liferay.portal.kernel.exception.SystemException {
772                    return getPersistence()
773                                       .findByN_T(nodeId, title, start, end, orderByComparator);
774            }
775    
776            /**
777            * Returns the first wiki page in the ordered set where nodeId = &#63; and title = &#63;.
778            *
779            * <p>
780            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
781            * </p>
782            *
783            * @param nodeId the node ID
784            * @param title the title
785            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
786            * @return the first matching wiki page
787            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
788            * @throws SystemException if a system exception occurred
789            */
790            public static com.liferay.portlet.wiki.model.WikiPage findByN_T_First(
791                    long nodeId, java.lang.String title,
792                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
793                    throws com.liferay.portal.kernel.exception.SystemException,
794                            com.liferay.portlet.wiki.NoSuchPageException {
795                    return getPersistence().findByN_T_First(nodeId, title, orderByComparator);
796            }
797    
798            /**
799            * Returns the last wiki page in the ordered set where nodeId = &#63; and title = &#63;.
800            *
801            * <p>
802            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
803            * </p>
804            *
805            * @param nodeId the node ID
806            * @param title the title
807            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
808            * @return the last matching wiki page
809            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
810            * @throws SystemException if a system exception occurred
811            */
812            public static com.liferay.portlet.wiki.model.WikiPage findByN_T_Last(
813                    long nodeId, java.lang.String title,
814                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
815                    throws com.liferay.portal.kernel.exception.SystemException,
816                            com.liferay.portlet.wiki.NoSuchPageException {
817                    return getPersistence().findByN_T_Last(nodeId, title, orderByComparator);
818            }
819    
820            /**
821            * Returns the wiki pages before and after the current wiki page in the ordered set where nodeId = &#63; and title = &#63;.
822            *
823            * <p>
824            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
825            * </p>
826            *
827            * @param pageId the primary key of the current wiki page
828            * @param nodeId the node ID
829            * @param title the title
830            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
831            * @return the previous, current, and next wiki page
832            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
833            * @throws SystemException if a system exception occurred
834            */
835            public static com.liferay.portlet.wiki.model.WikiPage[] findByN_T_PrevAndNext(
836                    long pageId, long nodeId, java.lang.String title,
837                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
838                    throws com.liferay.portal.kernel.exception.SystemException,
839                            com.liferay.portlet.wiki.NoSuchPageException {
840                    return getPersistence()
841                                       .findByN_T_PrevAndNext(pageId, nodeId, title,
842                            orderByComparator);
843            }
844    
845            /**
846            * Returns all the wiki pages where nodeId = &#63; and head = &#63;.
847            *
848            * @param nodeId the node ID
849            * @param head the head
850            * @return the matching wiki pages
851            * @throws SystemException if a system exception occurred
852            */
853            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_H(
854                    long nodeId, boolean head)
855                    throws com.liferay.portal.kernel.exception.SystemException {
856                    return getPersistence().findByN_H(nodeId, head);
857            }
858    
859            /**
860            * Returns a range of all the wiki pages where nodeId = &#63; and head = &#63;.
861            *
862            * <p>
863            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
864            * </p>
865            *
866            * @param nodeId the node ID
867            * @param head the head
868            * @param start the lower bound of the range of wiki pages
869            * @param end the upper bound of the range of wiki pages (not inclusive)
870            * @return the range of matching wiki pages
871            * @throws SystemException if a system exception occurred
872            */
873            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_H(
874                    long nodeId, boolean head, int start, int end)
875                    throws com.liferay.portal.kernel.exception.SystemException {
876                    return getPersistence().findByN_H(nodeId, head, start, end);
877            }
878    
879            /**
880            * Returns an ordered range of all the wiki pages where nodeId = &#63; and head = &#63;.
881            *
882            * <p>
883            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
884            * </p>
885            *
886            * @param nodeId the node ID
887            * @param head the head
888            * @param start the lower bound of the range of wiki pages
889            * @param end the upper bound of the range of wiki pages (not inclusive)
890            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
891            * @return the ordered range of matching wiki pages
892            * @throws SystemException if a system exception occurred
893            */
894            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_H(
895                    long nodeId, boolean head, int start, int end,
896                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
897                    throws com.liferay.portal.kernel.exception.SystemException {
898                    return getPersistence()
899                                       .findByN_H(nodeId, head, start, end, orderByComparator);
900            }
901    
902            /**
903            * Returns the first wiki page in the ordered set where nodeId = &#63; and head = &#63;.
904            *
905            * <p>
906            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
907            * </p>
908            *
909            * @param nodeId the node ID
910            * @param head the head
911            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
912            * @return the first matching wiki page
913            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
914            * @throws SystemException if a system exception occurred
915            */
916            public static com.liferay.portlet.wiki.model.WikiPage findByN_H_First(
917                    long nodeId, boolean head,
918                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
919                    throws com.liferay.portal.kernel.exception.SystemException,
920                            com.liferay.portlet.wiki.NoSuchPageException {
921                    return getPersistence().findByN_H_First(nodeId, head, orderByComparator);
922            }
923    
924            /**
925            * Returns the last wiki page in the ordered set where nodeId = &#63; and head = &#63;.
926            *
927            * <p>
928            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
929            * </p>
930            *
931            * @param nodeId the node ID
932            * @param head the head
933            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
934            * @return the last matching wiki page
935            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
936            * @throws SystemException if a system exception occurred
937            */
938            public static com.liferay.portlet.wiki.model.WikiPage findByN_H_Last(
939                    long nodeId, boolean head,
940                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
941                    throws com.liferay.portal.kernel.exception.SystemException,
942                            com.liferay.portlet.wiki.NoSuchPageException {
943                    return getPersistence().findByN_H_Last(nodeId, head, orderByComparator);
944            }
945    
946            /**
947            * Returns the wiki pages before and after the current wiki page in the ordered set where nodeId = &#63; and head = &#63;.
948            *
949            * <p>
950            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
951            * </p>
952            *
953            * @param pageId the primary key of the current wiki page
954            * @param nodeId the node ID
955            * @param head the head
956            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
957            * @return the previous, current, and next wiki page
958            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
959            * @throws SystemException if a system exception occurred
960            */
961            public static com.liferay.portlet.wiki.model.WikiPage[] findByN_H_PrevAndNext(
962                    long pageId, long nodeId, boolean head,
963                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
964                    throws com.liferay.portal.kernel.exception.SystemException,
965                            com.liferay.portlet.wiki.NoSuchPageException {
966                    return getPersistence()
967                                       .findByN_H_PrevAndNext(pageId, nodeId, head,
968                            orderByComparator);
969            }
970    
971            /**
972            * Returns all the wiki pages where nodeId = &#63; and parentTitle = &#63;.
973            *
974            * @param nodeId the node ID
975            * @param parentTitle the parent title
976            * @return the matching wiki pages
977            * @throws SystemException if a system exception occurred
978            */
979            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_P(
980                    long nodeId, java.lang.String parentTitle)
981                    throws com.liferay.portal.kernel.exception.SystemException {
982                    return getPersistence().findByN_P(nodeId, parentTitle);
983            }
984    
985            /**
986            * Returns a range of all the wiki pages where nodeId = &#63; and parentTitle = &#63;.
987            *
988            * <p>
989            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
990            * </p>
991            *
992            * @param nodeId the node ID
993            * @param parentTitle the parent title
994            * @param start the lower bound of the range of wiki pages
995            * @param end the upper bound of the range of wiki pages (not inclusive)
996            * @return the range of matching wiki pages
997            * @throws SystemException if a system exception occurred
998            */
999            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_P(
1000                    long nodeId, java.lang.String parentTitle, int start, int end)
1001                    throws com.liferay.portal.kernel.exception.SystemException {
1002                    return getPersistence().findByN_P(nodeId, parentTitle, start, end);
1003            }
1004    
1005            /**
1006            * Returns an ordered range of all the wiki pages where nodeId = &#63; and parentTitle = &#63;.
1007            *
1008            * <p>
1009            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1010            * </p>
1011            *
1012            * @param nodeId the node ID
1013            * @param parentTitle the parent title
1014            * @param start the lower bound of the range of wiki pages
1015            * @param end the upper bound of the range of wiki pages (not inclusive)
1016            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1017            * @return the ordered range of matching wiki pages
1018            * @throws SystemException if a system exception occurred
1019            */
1020            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_P(
1021                    long nodeId, java.lang.String parentTitle, int start, int end,
1022                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1023                    throws com.liferay.portal.kernel.exception.SystemException {
1024                    return getPersistence()
1025                                       .findByN_P(nodeId, parentTitle, start, end, orderByComparator);
1026            }
1027    
1028            /**
1029            * Returns the first wiki page in the ordered set where nodeId = &#63; and parentTitle = &#63;.
1030            *
1031            * <p>
1032            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1033            * </p>
1034            *
1035            * @param nodeId the node ID
1036            * @param parentTitle the parent title
1037            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1038            * @return the first matching wiki page
1039            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
1040            * @throws SystemException if a system exception occurred
1041            */
1042            public static com.liferay.portlet.wiki.model.WikiPage findByN_P_First(
1043                    long nodeId, java.lang.String parentTitle,
1044                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1045                    throws com.liferay.portal.kernel.exception.SystemException,
1046                            com.liferay.portlet.wiki.NoSuchPageException {
1047                    return getPersistence()
1048                                       .findByN_P_First(nodeId, parentTitle, orderByComparator);
1049            }
1050    
1051            /**
1052            * Returns the last wiki page in the ordered set where nodeId = &#63; and parentTitle = &#63;.
1053            *
1054            * <p>
1055            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1056            * </p>
1057            *
1058            * @param nodeId the node ID
1059            * @param parentTitle the parent title
1060            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1061            * @return the last matching wiki page
1062            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
1063            * @throws SystemException if a system exception occurred
1064            */
1065            public static com.liferay.portlet.wiki.model.WikiPage findByN_P_Last(
1066                    long nodeId, java.lang.String parentTitle,
1067                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1068                    throws com.liferay.portal.kernel.exception.SystemException,
1069                            com.liferay.portlet.wiki.NoSuchPageException {
1070                    return getPersistence()
1071                                       .findByN_P_Last(nodeId, parentTitle, orderByComparator);
1072            }
1073    
1074            /**
1075            * Returns the wiki pages before and after the current wiki page in the ordered set where nodeId = &#63; and parentTitle = &#63;.
1076            *
1077            * <p>
1078            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1079            * </p>
1080            *
1081            * @param pageId the primary key of the current wiki page
1082            * @param nodeId the node ID
1083            * @param parentTitle the parent title
1084            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1085            * @return the previous, current, and next wiki page
1086            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
1087            * @throws SystemException if a system exception occurred
1088            */
1089            public static com.liferay.portlet.wiki.model.WikiPage[] findByN_P_PrevAndNext(
1090                    long pageId, long nodeId, java.lang.String parentTitle,
1091                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1092                    throws com.liferay.portal.kernel.exception.SystemException,
1093                            com.liferay.portlet.wiki.NoSuchPageException {
1094                    return getPersistence()
1095                                       .findByN_P_PrevAndNext(pageId, nodeId, parentTitle,
1096                            orderByComparator);
1097            }
1098    
1099            /**
1100            * Returns all the wiki pages where nodeId = &#63; and redirectTitle = &#63;.
1101            *
1102            * @param nodeId the node ID
1103            * @param redirectTitle the redirect title
1104            * @return the matching wiki pages
1105            * @throws SystemException if a system exception occurred
1106            */
1107            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_R(
1108                    long nodeId, java.lang.String redirectTitle)
1109                    throws com.liferay.portal.kernel.exception.SystemException {
1110                    return getPersistence().findByN_R(nodeId, redirectTitle);
1111            }
1112    
1113            /**
1114            * Returns a range of all the wiki pages where nodeId = &#63; and redirectTitle = &#63;.
1115            *
1116            * <p>
1117            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1118            * </p>
1119            *
1120            * @param nodeId the node ID
1121            * @param redirectTitle the redirect title
1122            * @param start the lower bound of the range of wiki pages
1123            * @param end the upper bound of the range of wiki pages (not inclusive)
1124            * @return the range of matching wiki pages
1125            * @throws SystemException if a system exception occurred
1126            */
1127            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_R(
1128                    long nodeId, java.lang.String redirectTitle, int start, int end)
1129                    throws com.liferay.portal.kernel.exception.SystemException {
1130                    return getPersistence().findByN_R(nodeId, redirectTitle, start, end);
1131            }
1132    
1133            /**
1134            * Returns an ordered range of all the wiki pages where nodeId = &#63; and redirectTitle = &#63;.
1135            *
1136            * <p>
1137            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1138            * </p>
1139            *
1140            * @param nodeId the node ID
1141            * @param redirectTitle the redirect title
1142            * @param start the lower bound of the range of wiki pages
1143            * @param end the upper bound of the range of wiki pages (not inclusive)
1144            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1145            * @return the ordered range of matching wiki pages
1146            * @throws SystemException if a system exception occurred
1147            */
1148            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_R(
1149                    long nodeId, java.lang.String redirectTitle, int start, int end,
1150                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1151                    throws com.liferay.portal.kernel.exception.SystemException {
1152                    return getPersistence()
1153                                       .findByN_R(nodeId, redirectTitle, start, end,
1154                            orderByComparator);
1155            }
1156    
1157            /**
1158            * Returns the first wiki page in the ordered set where nodeId = &#63; and redirectTitle = &#63;.
1159            *
1160            * <p>
1161            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1162            * </p>
1163            *
1164            * @param nodeId the node ID
1165            * @param redirectTitle the redirect title
1166            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1167            * @return the first matching wiki page
1168            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
1169            * @throws SystemException if a system exception occurred
1170            */
1171            public static com.liferay.portlet.wiki.model.WikiPage findByN_R_First(
1172                    long nodeId, java.lang.String redirectTitle,
1173                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1174                    throws com.liferay.portal.kernel.exception.SystemException,
1175                            com.liferay.portlet.wiki.NoSuchPageException {
1176                    return getPersistence()
1177                                       .findByN_R_First(nodeId, redirectTitle, orderByComparator);
1178            }
1179    
1180            /**
1181            * Returns the last wiki page in the ordered set where nodeId = &#63; and redirectTitle = &#63;.
1182            *
1183            * <p>
1184            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1185            * </p>
1186            *
1187            * @param nodeId the node ID
1188            * @param redirectTitle the redirect title
1189            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1190            * @return the last matching wiki page
1191            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
1192            * @throws SystemException if a system exception occurred
1193            */
1194            public static com.liferay.portlet.wiki.model.WikiPage findByN_R_Last(
1195                    long nodeId, java.lang.String redirectTitle,
1196                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1197                    throws com.liferay.portal.kernel.exception.SystemException,
1198                            com.liferay.portlet.wiki.NoSuchPageException {
1199                    return getPersistence()
1200                                       .findByN_R_Last(nodeId, redirectTitle, orderByComparator);
1201            }
1202    
1203            /**
1204            * Returns the wiki pages before and after the current wiki page in the ordered set where nodeId = &#63; and redirectTitle = &#63;.
1205            *
1206            * <p>
1207            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1208            * </p>
1209            *
1210            * @param pageId the primary key of the current wiki page
1211            * @param nodeId the node ID
1212            * @param redirectTitle the redirect title
1213            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1214            * @return the previous, current, and next wiki page
1215            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
1216            * @throws SystemException if a system exception occurred
1217            */
1218            public static com.liferay.portlet.wiki.model.WikiPage[] findByN_R_PrevAndNext(
1219                    long pageId, long nodeId, java.lang.String redirectTitle,
1220                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1221                    throws com.liferay.portal.kernel.exception.SystemException,
1222                            com.liferay.portlet.wiki.NoSuchPageException {
1223                    return getPersistence()
1224                                       .findByN_R_PrevAndNext(pageId, nodeId, redirectTitle,
1225                            orderByComparator);
1226            }
1227    
1228            /**
1229            * Returns all the wiki pages where nodeId = &#63; and status = &#63;.
1230            *
1231            * @param nodeId the node ID
1232            * @param status the status
1233            * @return the matching wiki pages
1234            * @throws SystemException if a system exception occurred
1235            */
1236            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_S(
1237                    long nodeId, int status)
1238                    throws com.liferay.portal.kernel.exception.SystemException {
1239                    return getPersistence().findByN_S(nodeId, status);
1240            }
1241    
1242            /**
1243            * Returns a range of all the wiki pages where nodeId = &#63; and status = &#63;.
1244            *
1245            * <p>
1246            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1247            * </p>
1248            *
1249            * @param nodeId the node ID
1250            * @param status the status
1251            * @param start the lower bound of the range of wiki pages
1252            * @param end the upper bound of the range of wiki pages (not inclusive)
1253            * @return the range of matching wiki pages
1254            * @throws SystemException if a system exception occurred
1255            */
1256            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_S(
1257                    long nodeId, int status, int start, int end)
1258                    throws com.liferay.portal.kernel.exception.SystemException {
1259                    return getPersistence().findByN_S(nodeId, status, start, end);
1260            }
1261    
1262            /**
1263            * Returns an ordered range of all the wiki pages where nodeId = &#63; and status = &#63;.
1264            *
1265            * <p>
1266            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1267            * </p>
1268            *
1269            * @param nodeId the node ID
1270            * @param status the status
1271            * @param start the lower bound of the range of wiki pages
1272            * @param end the upper bound of the range of wiki pages (not inclusive)
1273            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1274            * @return the ordered range of matching wiki pages
1275            * @throws SystemException if a system exception occurred
1276            */
1277            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_S(
1278                    long nodeId, int status, int start, int end,
1279                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1280                    throws com.liferay.portal.kernel.exception.SystemException {
1281                    return getPersistence()
1282                                       .findByN_S(nodeId, status, start, end, orderByComparator);
1283            }
1284    
1285            /**
1286            * Returns the first wiki page in the ordered set where nodeId = &#63; and status = &#63;.
1287            *
1288            * <p>
1289            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1290            * </p>
1291            *
1292            * @param nodeId the node ID
1293            * @param status the status
1294            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1295            * @return the first matching wiki page
1296            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
1297            * @throws SystemException if a system exception occurred
1298            */
1299            public static com.liferay.portlet.wiki.model.WikiPage findByN_S_First(
1300                    long nodeId, int status,
1301                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1302                    throws com.liferay.portal.kernel.exception.SystemException,
1303                            com.liferay.portlet.wiki.NoSuchPageException {
1304                    return getPersistence()
1305                                       .findByN_S_First(nodeId, status, orderByComparator);
1306            }
1307    
1308            /**
1309            * Returns the last wiki page in the ordered set where nodeId = &#63; and status = &#63;.
1310            *
1311            * <p>
1312            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1313            * </p>
1314            *
1315            * @param nodeId the node ID
1316            * @param status the status
1317            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1318            * @return the last matching wiki page
1319            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
1320            * @throws SystemException if a system exception occurred
1321            */
1322            public static com.liferay.portlet.wiki.model.WikiPage findByN_S_Last(
1323                    long nodeId, int status,
1324                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1325                    throws com.liferay.portal.kernel.exception.SystemException,
1326                            com.liferay.portlet.wiki.NoSuchPageException {
1327                    return getPersistence().findByN_S_Last(nodeId, status, orderByComparator);
1328            }
1329    
1330            /**
1331            * Returns the wiki pages before and after the current wiki page in the ordered set where nodeId = &#63; and status = &#63;.
1332            *
1333            * <p>
1334            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1335            * </p>
1336            *
1337            * @param pageId the primary key of the current wiki page
1338            * @param nodeId the node ID
1339            * @param status the status
1340            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1341            * @return the previous, current, and next wiki page
1342            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
1343            * @throws SystemException if a system exception occurred
1344            */
1345            public static com.liferay.portlet.wiki.model.WikiPage[] findByN_S_PrevAndNext(
1346                    long pageId, long nodeId, int status,
1347                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1348                    throws com.liferay.portal.kernel.exception.SystemException,
1349                            com.liferay.portlet.wiki.NoSuchPageException {
1350                    return getPersistence()
1351                                       .findByN_S_PrevAndNext(pageId, nodeId, status,
1352                            orderByComparator);
1353            }
1354    
1355            /**
1356            * Returns the wiki page where resourcePrimKey = &#63; and nodeId = &#63; and version = &#63; or throws a {@link com.liferay.portlet.wiki.NoSuchPageException} if it could not be found.
1357            *
1358            * @param resourcePrimKey the resource prim key
1359            * @param nodeId the node ID
1360            * @param version the version
1361            * @return the matching wiki page
1362            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
1363            * @throws SystemException if a system exception occurred
1364            */
1365            public static com.liferay.portlet.wiki.model.WikiPage findByR_N_V(
1366                    long resourcePrimKey, long nodeId, double version)
1367                    throws com.liferay.portal.kernel.exception.SystemException,
1368                            com.liferay.portlet.wiki.NoSuchPageException {
1369                    return getPersistence().findByR_N_V(resourcePrimKey, nodeId, version);
1370            }
1371    
1372            /**
1373            * Returns the wiki page where resourcePrimKey = &#63; and nodeId = &#63; and version = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1374            *
1375            * @param resourcePrimKey the resource prim key
1376            * @param nodeId the node ID
1377            * @param version the version
1378            * @return the matching wiki page, or <code>null</code> if a matching wiki page could not be found
1379            * @throws SystemException if a system exception occurred
1380            */
1381            public static com.liferay.portlet.wiki.model.WikiPage fetchByR_N_V(
1382                    long resourcePrimKey, long nodeId, double version)
1383                    throws com.liferay.portal.kernel.exception.SystemException {
1384                    return getPersistence().fetchByR_N_V(resourcePrimKey, nodeId, version);
1385            }
1386    
1387            /**
1388            * Returns the wiki page where resourcePrimKey = &#63; and nodeId = &#63; and version = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1389            *
1390            * @param resourcePrimKey the resource prim key
1391            * @param nodeId the node ID
1392            * @param version the version
1393            * @param retrieveFromCache whether to use the finder cache
1394            * @return the matching wiki page, or <code>null</code> if a matching wiki page could not be found
1395            * @throws SystemException if a system exception occurred
1396            */
1397            public static com.liferay.portlet.wiki.model.WikiPage fetchByR_N_V(
1398                    long resourcePrimKey, long nodeId, double version,
1399                    boolean retrieveFromCache)
1400                    throws com.liferay.portal.kernel.exception.SystemException {
1401                    return getPersistence()
1402                                       .fetchByR_N_V(resourcePrimKey, nodeId, version,
1403                            retrieveFromCache);
1404            }
1405    
1406            /**
1407            * Returns all the wiki pages where resourcePrimKey = &#63; and nodeId = &#63; and status = &#63;.
1408            *
1409            * @param resourcePrimKey the resource prim key
1410            * @param nodeId the node ID
1411            * @param status the status
1412            * @return the matching wiki pages
1413            * @throws SystemException if a system exception occurred
1414            */
1415            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByR_N_S(
1416                    long resourcePrimKey, long nodeId, int status)
1417                    throws com.liferay.portal.kernel.exception.SystemException {
1418                    return getPersistence().findByR_N_S(resourcePrimKey, nodeId, status);
1419            }
1420    
1421            /**
1422            * Returns a range of all the wiki pages where resourcePrimKey = &#63; and nodeId = &#63; and status = &#63;.
1423            *
1424            * <p>
1425            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1426            * </p>
1427            *
1428            * @param resourcePrimKey the resource prim key
1429            * @param nodeId the node ID
1430            * @param status the status
1431            * @param start the lower bound of the range of wiki pages
1432            * @param end the upper bound of the range of wiki pages (not inclusive)
1433            * @return the range of matching wiki pages
1434            * @throws SystemException if a system exception occurred
1435            */
1436            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByR_N_S(
1437                    long resourcePrimKey, long nodeId, int status, int start, int end)
1438                    throws com.liferay.portal.kernel.exception.SystemException {
1439                    return getPersistence()
1440                                       .findByR_N_S(resourcePrimKey, nodeId, status, start, end);
1441            }
1442    
1443            /**
1444            * Returns an ordered range of all the wiki pages where resourcePrimKey = &#63; and nodeId = &#63; and status = &#63;.
1445            *
1446            * <p>
1447            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1448            * </p>
1449            *
1450            * @param resourcePrimKey the resource prim key
1451            * @param nodeId the node ID
1452            * @param status the status
1453            * @param start the lower bound of the range of wiki pages
1454            * @param end the upper bound of the range of wiki pages (not inclusive)
1455            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1456            * @return the ordered range of matching wiki pages
1457            * @throws SystemException if a system exception occurred
1458            */
1459            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByR_N_S(
1460                    long resourcePrimKey, long nodeId, int status, int start, int end,
1461                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1462                    throws com.liferay.portal.kernel.exception.SystemException {
1463                    return getPersistence()
1464                                       .findByR_N_S(resourcePrimKey, nodeId, status, start, end,
1465                            orderByComparator);
1466            }
1467    
1468            /**
1469            * Returns the first wiki page in the ordered set where resourcePrimKey = &#63; and nodeId = &#63; and status = &#63;.
1470            *
1471            * <p>
1472            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1473            * </p>
1474            *
1475            * @param resourcePrimKey the resource prim key
1476            * @param nodeId the node ID
1477            * @param status the status
1478            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1479            * @return the first matching wiki page
1480            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
1481            * @throws SystemException if a system exception occurred
1482            */
1483            public static com.liferay.portlet.wiki.model.WikiPage findByR_N_S_First(
1484                    long resourcePrimKey, long nodeId, int status,
1485                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1486                    throws com.liferay.portal.kernel.exception.SystemException,
1487                            com.liferay.portlet.wiki.NoSuchPageException {
1488                    return getPersistence()
1489                                       .findByR_N_S_First(resourcePrimKey, nodeId, status,
1490                            orderByComparator);
1491            }
1492    
1493            /**
1494            * Returns the last wiki page in the ordered set where resourcePrimKey = &#63; and nodeId = &#63; and status = &#63;.
1495            *
1496            * <p>
1497            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1498            * </p>
1499            *
1500            * @param resourcePrimKey the resource prim key
1501            * @param nodeId the node ID
1502            * @param status the status
1503            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1504            * @return the last matching wiki page
1505            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
1506            * @throws SystemException if a system exception occurred
1507            */
1508            public static com.liferay.portlet.wiki.model.WikiPage findByR_N_S_Last(
1509                    long resourcePrimKey, long nodeId, int status,
1510                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1511                    throws com.liferay.portal.kernel.exception.SystemException,
1512                            com.liferay.portlet.wiki.NoSuchPageException {
1513                    return getPersistence()
1514                                       .findByR_N_S_Last(resourcePrimKey, nodeId, status,
1515                            orderByComparator);
1516            }
1517    
1518            /**
1519            * Returns the wiki pages before and after the current wiki page in the ordered set where resourcePrimKey = &#63; and nodeId = &#63; and status = &#63;.
1520            *
1521            * <p>
1522            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1523            * </p>
1524            *
1525            * @param pageId the primary key of the current wiki page
1526            * @param resourcePrimKey the resource prim key
1527            * @param nodeId the node ID
1528            * @param status the status
1529            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1530            * @return the previous, current, and next wiki page
1531            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
1532            * @throws SystemException if a system exception occurred
1533            */
1534            public static com.liferay.portlet.wiki.model.WikiPage[] findByR_N_S_PrevAndNext(
1535                    long pageId, long resourcePrimKey, long nodeId, int status,
1536                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1537                    throws com.liferay.portal.kernel.exception.SystemException,
1538                            com.liferay.portlet.wiki.NoSuchPageException {
1539                    return getPersistence()
1540                                       .findByR_N_S_PrevAndNext(pageId, resourcePrimKey, nodeId,
1541                            status, orderByComparator);
1542            }
1543    
1544            /**
1545            * Returns all the wiki pages where userId = &#63; and nodeId = &#63; and status = &#63;.
1546            *
1547            * @param userId the user ID
1548            * @param nodeId the node ID
1549            * @param status the status
1550            * @return the matching wiki pages
1551            * @throws SystemException if a system exception occurred
1552            */
1553            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByU_N_S(
1554                    long userId, long nodeId, int status)
1555                    throws com.liferay.portal.kernel.exception.SystemException {
1556                    return getPersistence().findByU_N_S(userId, nodeId, status);
1557            }
1558    
1559            /**
1560            * Returns a range of all the wiki pages where userId = &#63; and nodeId = &#63; and status = &#63;.
1561            *
1562            * <p>
1563            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1564            * </p>
1565            *
1566            * @param userId the user ID
1567            * @param nodeId the node ID
1568            * @param status the status
1569            * @param start the lower bound of the range of wiki pages
1570            * @param end the upper bound of the range of wiki pages (not inclusive)
1571            * @return the range of matching wiki pages
1572            * @throws SystemException if a system exception occurred
1573            */
1574            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByU_N_S(
1575                    long userId, long nodeId, int status, int start, int end)
1576                    throws com.liferay.portal.kernel.exception.SystemException {
1577                    return getPersistence().findByU_N_S(userId, nodeId, status, start, end);
1578            }
1579    
1580            /**
1581            * Returns an ordered range of all the wiki pages where userId = &#63; and nodeId = &#63; and status = &#63;.
1582            *
1583            * <p>
1584            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1585            * </p>
1586            *
1587            * @param userId the user ID
1588            * @param nodeId the node ID
1589            * @param status the status
1590            * @param start the lower bound of the range of wiki pages
1591            * @param end the upper bound of the range of wiki pages (not inclusive)
1592            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1593            * @return the ordered range of matching wiki pages
1594            * @throws SystemException if a system exception occurred
1595            */
1596            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByU_N_S(
1597                    long userId, long nodeId, int status, int start, int end,
1598                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1599                    throws com.liferay.portal.kernel.exception.SystemException {
1600                    return getPersistence()
1601                                       .findByU_N_S(userId, nodeId, status, start, end,
1602                            orderByComparator);
1603            }
1604    
1605            /**
1606            * Returns the first wiki page in the ordered set where userId = &#63; and nodeId = &#63; and status = &#63;.
1607            *
1608            * <p>
1609            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1610            * </p>
1611            *
1612            * @param userId the user ID
1613            * @param nodeId the node ID
1614            * @param status the status
1615            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1616            * @return the first matching wiki page
1617            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
1618            * @throws SystemException if a system exception occurred
1619            */
1620            public static com.liferay.portlet.wiki.model.WikiPage findByU_N_S_First(
1621                    long userId, long nodeId, int status,
1622                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1623                    throws com.liferay.portal.kernel.exception.SystemException,
1624                            com.liferay.portlet.wiki.NoSuchPageException {
1625                    return getPersistence()
1626                                       .findByU_N_S_First(userId, nodeId, status, orderByComparator);
1627            }
1628    
1629            /**
1630            * Returns the last wiki page in the ordered set where userId = &#63; and nodeId = &#63; and status = &#63;.
1631            *
1632            * <p>
1633            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1634            * </p>
1635            *
1636            * @param userId the user ID
1637            * @param nodeId the node ID
1638            * @param status the status
1639            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1640            * @return the last matching wiki page
1641            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
1642            * @throws SystemException if a system exception occurred
1643            */
1644            public static com.liferay.portlet.wiki.model.WikiPage findByU_N_S_Last(
1645                    long userId, long nodeId, int status,
1646                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1647                    throws com.liferay.portal.kernel.exception.SystemException,
1648                            com.liferay.portlet.wiki.NoSuchPageException {
1649                    return getPersistence()
1650                                       .findByU_N_S_Last(userId, nodeId, status, orderByComparator);
1651            }
1652    
1653            /**
1654            * Returns the wiki pages before and after the current wiki page in the ordered set where userId = &#63; and nodeId = &#63; and status = &#63;.
1655            *
1656            * <p>
1657            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1658            * </p>
1659            *
1660            * @param pageId the primary key of the current wiki page
1661            * @param userId the user ID
1662            * @param nodeId the node ID
1663            * @param status the status
1664            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1665            * @return the previous, current, and next wiki page
1666            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
1667            * @throws SystemException if a system exception occurred
1668            */
1669            public static com.liferay.portlet.wiki.model.WikiPage[] findByU_N_S_PrevAndNext(
1670                    long pageId, long userId, long nodeId, int status,
1671                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1672                    throws com.liferay.portal.kernel.exception.SystemException,
1673                            com.liferay.portlet.wiki.NoSuchPageException {
1674                    return getPersistence()
1675                                       .findByU_N_S_PrevAndNext(pageId, userId, nodeId, status,
1676                            orderByComparator);
1677            }
1678    
1679            /**
1680            * Returns the wiki page where nodeId = &#63; and title = &#63; and version = &#63; or throws a {@link com.liferay.portlet.wiki.NoSuchPageException} if it could not be found.
1681            *
1682            * @param nodeId the node ID
1683            * @param title the title
1684            * @param version the version
1685            * @return the matching wiki page
1686            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
1687            * @throws SystemException if a system exception occurred
1688            */
1689            public static com.liferay.portlet.wiki.model.WikiPage findByN_T_V(
1690                    long nodeId, java.lang.String title, double version)
1691                    throws com.liferay.portal.kernel.exception.SystemException,
1692                            com.liferay.portlet.wiki.NoSuchPageException {
1693                    return getPersistence().findByN_T_V(nodeId, title, version);
1694            }
1695    
1696            /**
1697            * Returns the wiki page where nodeId = &#63; and title = &#63; and version = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1698            *
1699            * @param nodeId the node ID
1700            * @param title the title
1701            * @param version the version
1702            * @return the matching wiki page, or <code>null</code> if a matching wiki page could not be found
1703            * @throws SystemException if a system exception occurred
1704            */
1705            public static com.liferay.portlet.wiki.model.WikiPage fetchByN_T_V(
1706                    long nodeId, java.lang.String title, double version)
1707                    throws com.liferay.portal.kernel.exception.SystemException {
1708                    return getPersistence().fetchByN_T_V(nodeId, title, version);
1709            }
1710    
1711            /**
1712            * Returns the wiki page where nodeId = &#63; and title = &#63; and version = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1713            *
1714            * @param nodeId the node ID
1715            * @param title the title
1716            * @param version the version
1717            * @param retrieveFromCache whether to use the finder cache
1718            * @return the matching wiki page, or <code>null</code> if a matching wiki page could not be found
1719            * @throws SystemException if a system exception occurred
1720            */
1721            public static com.liferay.portlet.wiki.model.WikiPage fetchByN_T_V(
1722                    long nodeId, java.lang.String title, double version,
1723                    boolean retrieveFromCache)
1724                    throws com.liferay.portal.kernel.exception.SystemException {
1725                    return getPersistence()
1726                                       .fetchByN_T_V(nodeId, title, version, retrieveFromCache);
1727            }
1728    
1729            /**
1730            * Returns all the wiki pages where nodeId = &#63; and title = &#63; and head = &#63;.
1731            *
1732            * @param nodeId the node ID
1733            * @param title the title
1734            * @param head the head
1735            * @return the matching wiki pages
1736            * @throws SystemException if a system exception occurred
1737            */
1738            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_T_H(
1739                    long nodeId, java.lang.String title, boolean head)
1740                    throws com.liferay.portal.kernel.exception.SystemException {
1741                    return getPersistence().findByN_T_H(nodeId, title, head);
1742            }
1743    
1744            /**
1745            * Returns a range of all the wiki pages where nodeId = &#63; and title = &#63; and head = &#63;.
1746            *
1747            * <p>
1748            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1749            * </p>
1750            *
1751            * @param nodeId the node ID
1752            * @param title the title
1753            * @param head the head
1754            * @param start the lower bound of the range of wiki pages
1755            * @param end the upper bound of the range of wiki pages (not inclusive)
1756            * @return the range of matching wiki pages
1757            * @throws SystemException if a system exception occurred
1758            */
1759            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_T_H(
1760                    long nodeId, java.lang.String title, boolean head, int start, int end)
1761                    throws com.liferay.portal.kernel.exception.SystemException {
1762                    return getPersistence().findByN_T_H(nodeId, title, head, start, end);
1763            }
1764    
1765            /**
1766            * Returns an ordered range of all the wiki pages where nodeId = &#63; and title = &#63; and head = &#63;.
1767            *
1768            * <p>
1769            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1770            * </p>
1771            *
1772            * @param nodeId the node ID
1773            * @param title the title
1774            * @param head the head
1775            * @param start the lower bound of the range of wiki pages
1776            * @param end the upper bound of the range of wiki pages (not inclusive)
1777            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1778            * @return the ordered range of matching wiki pages
1779            * @throws SystemException if a system exception occurred
1780            */
1781            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_T_H(
1782                    long nodeId, java.lang.String title, boolean head, int start, int end,
1783                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1784                    throws com.liferay.portal.kernel.exception.SystemException {
1785                    return getPersistence()
1786                                       .findByN_T_H(nodeId, title, head, start, end,
1787                            orderByComparator);
1788            }
1789    
1790            /**
1791            * Returns the first wiki page in the ordered set where nodeId = &#63; and title = &#63; and head = &#63;.
1792            *
1793            * <p>
1794            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1795            * </p>
1796            *
1797            * @param nodeId the node ID
1798            * @param title the title
1799            * @param head the head
1800            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1801            * @return the first matching wiki page
1802            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
1803            * @throws SystemException if a system exception occurred
1804            */
1805            public static com.liferay.portlet.wiki.model.WikiPage findByN_T_H_First(
1806                    long nodeId, java.lang.String title, boolean head,
1807                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1808                    throws com.liferay.portal.kernel.exception.SystemException,
1809                            com.liferay.portlet.wiki.NoSuchPageException {
1810                    return getPersistence()
1811                                       .findByN_T_H_First(nodeId, title, head, orderByComparator);
1812            }
1813    
1814            /**
1815            * Returns the last wiki page in the ordered set where nodeId = &#63; and title = &#63; and head = &#63;.
1816            *
1817            * <p>
1818            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1819            * </p>
1820            *
1821            * @param nodeId the node ID
1822            * @param title the title
1823            * @param head the head
1824            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1825            * @return the last matching wiki page
1826            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
1827            * @throws SystemException if a system exception occurred
1828            */
1829            public static com.liferay.portlet.wiki.model.WikiPage findByN_T_H_Last(
1830                    long nodeId, java.lang.String title, boolean head,
1831                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1832                    throws com.liferay.portal.kernel.exception.SystemException,
1833                            com.liferay.portlet.wiki.NoSuchPageException {
1834                    return getPersistence()
1835                                       .findByN_T_H_Last(nodeId, title, head, orderByComparator);
1836            }
1837    
1838            /**
1839            * Returns the wiki pages before and after the current wiki page in the ordered set where nodeId = &#63; and title = &#63; and head = &#63;.
1840            *
1841            * <p>
1842            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1843            * </p>
1844            *
1845            * @param pageId the primary key of the current wiki page
1846            * @param nodeId the node ID
1847            * @param title the title
1848            * @param head the head
1849            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1850            * @return the previous, current, and next wiki page
1851            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
1852            * @throws SystemException if a system exception occurred
1853            */
1854            public static com.liferay.portlet.wiki.model.WikiPage[] findByN_T_H_PrevAndNext(
1855                    long pageId, long nodeId, java.lang.String title, boolean head,
1856                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1857                    throws com.liferay.portal.kernel.exception.SystemException,
1858                            com.liferay.portlet.wiki.NoSuchPageException {
1859                    return getPersistence()
1860                                       .findByN_T_H_PrevAndNext(pageId, nodeId, title, head,
1861                            orderByComparator);
1862            }
1863    
1864            /**
1865            * Returns all the wiki pages where nodeId = &#63; and title = &#63; and status = &#63;.
1866            *
1867            * @param nodeId the node ID
1868            * @param title the title
1869            * @param status the status
1870            * @return the matching wiki pages
1871            * @throws SystemException if a system exception occurred
1872            */
1873            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_T_S(
1874                    long nodeId, java.lang.String title, int status)
1875                    throws com.liferay.portal.kernel.exception.SystemException {
1876                    return getPersistence().findByN_T_S(nodeId, title, status);
1877            }
1878    
1879            /**
1880            * Returns a range of all the wiki pages where nodeId = &#63; and title = &#63; and status = &#63;.
1881            *
1882            * <p>
1883            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1884            * </p>
1885            *
1886            * @param nodeId the node ID
1887            * @param title the title
1888            * @param status the status
1889            * @param start the lower bound of the range of wiki pages
1890            * @param end the upper bound of the range of wiki pages (not inclusive)
1891            * @return the range of matching wiki pages
1892            * @throws SystemException if a system exception occurred
1893            */
1894            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_T_S(
1895                    long nodeId, java.lang.String title, int status, int start, int end)
1896                    throws com.liferay.portal.kernel.exception.SystemException {
1897                    return getPersistence().findByN_T_S(nodeId, title, status, start, end);
1898            }
1899    
1900            /**
1901            * Returns an ordered range of all the wiki pages where nodeId = &#63; and title = &#63; and status = &#63;.
1902            *
1903            * <p>
1904            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1905            * </p>
1906            *
1907            * @param nodeId the node ID
1908            * @param title the title
1909            * @param status the status
1910            * @param start the lower bound of the range of wiki pages
1911            * @param end the upper bound of the range of wiki pages (not inclusive)
1912            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1913            * @return the ordered range of matching wiki pages
1914            * @throws SystemException if a system exception occurred
1915            */
1916            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_T_S(
1917                    long nodeId, java.lang.String title, int status, int start, int end,
1918                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1919                    throws com.liferay.portal.kernel.exception.SystemException {
1920                    return getPersistence()
1921                                       .findByN_T_S(nodeId, title, status, start, end,
1922                            orderByComparator);
1923            }
1924    
1925            /**
1926            * Returns the first wiki page in the ordered set where nodeId = &#63; and title = &#63; and status = &#63;.
1927            *
1928            * <p>
1929            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1930            * </p>
1931            *
1932            * @param nodeId the node ID
1933            * @param title the title
1934            * @param status the status
1935            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1936            * @return the first matching wiki page
1937            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
1938            * @throws SystemException if a system exception occurred
1939            */
1940            public static com.liferay.portlet.wiki.model.WikiPage findByN_T_S_First(
1941                    long nodeId, java.lang.String title, int status,
1942                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1943                    throws com.liferay.portal.kernel.exception.SystemException,
1944                            com.liferay.portlet.wiki.NoSuchPageException {
1945                    return getPersistence()
1946                                       .findByN_T_S_First(nodeId, title, status, orderByComparator);
1947            }
1948    
1949            /**
1950            * Returns the last wiki page in the ordered set where nodeId = &#63; and title = &#63; and status = &#63;.
1951            *
1952            * <p>
1953            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1954            * </p>
1955            *
1956            * @param nodeId the node ID
1957            * @param title the title
1958            * @param status the status
1959            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1960            * @return the last matching wiki page
1961            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
1962            * @throws SystemException if a system exception occurred
1963            */
1964            public static com.liferay.portlet.wiki.model.WikiPage findByN_T_S_Last(
1965                    long nodeId, java.lang.String title, int status,
1966                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1967                    throws com.liferay.portal.kernel.exception.SystemException,
1968                            com.liferay.portlet.wiki.NoSuchPageException {
1969                    return getPersistence()
1970                                       .findByN_T_S_Last(nodeId, title, status, orderByComparator);
1971            }
1972    
1973            /**
1974            * Returns the wiki pages before and after the current wiki page in the ordered set where nodeId = &#63; and title = &#63; and status = &#63;.
1975            *
1976            * <p>
1977            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1978            * </p>
1979            *
1980            * @param pageId the primary key of the current wiki page
1981            * @param nodeId the node ID
1982            * @param title the title
1983            * @param status the status
1984            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1985            * @return the previous, current, and next wiki page
1986            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
1987            * @throws SystemException if a system exception occurred
1988            */
1989            public static com.liferay.portlet.wiki.model.WikiPage[] findByN_T_S_PrevAndNext(
1990                    long pageId, long nodeId, java.lang.String title, int status,
1991                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1992                    throws com.liferay.portal.kernel.exception.SystemException,
1993                            com.liferay.portlet.wiki.NoSuchPageException {
1994                    return getPersistence()
1995                                       .findByN_T_S_PrevAndNext(pageId, nodeId, title, status,
1996                            orderByComparator);
1997            }
1998    
1999            /**
2000            * Returns all the wiki pages where nodeId = &#63; and head = &#63; and parentTitle = &#63;.
2001            *
2002            * @param nodeId the node ID
2003            * @param head the head
2004            * @param parentTitle the parent title
2005            * @return the matching wiki pages
2006            * @throws SystemException if a system exception occurred
2007            */
2008            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_H_P(
2009                    long nodeId, boolean head, java.lang.String parentTitle)
2010                    throws com.liferay.portal.kernel.exception.SystemException {
2011                    return getPersistence().findByN_H_P(nodeId, head, parentTitle);
2012            }
2013    
2014            /**
2015            * Returns a range of all the wiki pages where nodeId = &#63; and head = &#63; and parentTitle = &#63;.
2016            *
2017            * <p>
2018            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2019            * </p>
2020            *
2021            * @param nodeId the node ID
2022            * @param head the head
2023            * @param parentTitle the parent title
2024            * @param start the lower bound of the range of wiki pages
2025            * @param end the upper bound of the range of wiki pages (not inclusive)
2026            * @return the range of matching wiki pages
2027            * @throws SystemException if a system exception occurred
2028            */
2029            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_H_P(
2030                    long nodeId, boolean head, java.lang.String parentTitle, int start,
2031                    int end) throws com.liferay.portal.kernel.exception.SystemException {
2032                    return getPersistence()
2033                                       .findByN_H_P(nodeId, head, parentTitle, start, end);
2034            }
2035    
2036            /**
2037            * Returns an ordered range of all the wiki pages where nodeId = &#63; and head = &#63; and parentTitle = &#63;.
2038            *
2039            * <p>
2040            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2041            * </p>
2042            *
2043            * @param nodeId the node ID
2044            * @param head the head
2045            * @param parentTitle the parent title
2046            * @param start the lower bound of the range of wiki pages
2047            * @param end the upper bound of the range of wiki pages (not inclusive)
2048            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2049            * @return the ordered range of matching wiki pages
2050            * @throws SystemException if a system exception occurred
2051            */
2052            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_H_P(
2053                    long nodeId, boolean head, java.lang.String parentTitle, int start,
2054                    int end,
2055                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2056                    throws com.liferay.portal.kernel.exception.SystemException {
2057                    return getPersistence()
2058                                       .findByN_H_P(nodeId, head, parentTitle, start, end,
2059                            orderByComparator);
2060            }
2061    
2062            /**
2063            * Returns the first wiki page in the ordered set where nodeId = &#63; and head = &#63; and parentTitle = &#63;.
2064            *
2065            * <p>
2066            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2067            * </p>
2068            *
2069            * @param nodeId the node ID
2070            * @param head the head
2071            * @param parentTitle the parent title
2072            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2073            * @return the first matching wiki page
2074            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
2075            * @throws SystemException if a system exception occurred
2076            */
2077            public static com.liferay.portlet.wiki.model.WikiPage findByN_H_P_First(
2078                    long nodeId, boolean head, java.lang.String parentTitle,
2079                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2080                    throws com.liferay.portal.kernel.exception.SystemException,
2081                            com.liferay.portlet.wiki.NoSuchPageException {
2082                    return getPersistence()
2083                                       .findByN_H_P_First(nodeId, head, parentTitle,
2084                            orderByComparator);
2085            }
2086    
2087            /**
2088            * Returns the last wiki page in the ordered set where nodeId = &#63; and head = &#63; and parentTitle = &#63;.
2089            *
2090            * <p>
2091            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2092            * </p>
2093            *
2094            * @param nodeId the node ID
2095            * @param head the head
2096            * @param parentTitle the parent title
2097            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2098            * @return the last matching wiki page
2099            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
2100            * @throws SystemException if a system exception occurred
2101            */
2102            public static com.liferay.portlet.wiki.model.WikiPage findByN_H_P_Last(
2103                    long nodeId, boolean head, java.lang.String parentTitle,
2104                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2105                    throws com.liferay.portal.kernel.exception.SystemException,
2106                            com.liferay.portlet.wiki.NoSuchPageException {
2107                    return getPersistence()
2108                                       .findByN_H_P_Last(nodeId, head, parentTitle,
2109                            orderByComparator);
2110            }
2111    
2112            /**
2113            * Returns the wiki pages before and after the current wiki page in the ordered set where nodeId = &#63; and head = &#63; and parentTitle = &#63;.
2114            *
2115            * <p>
2116            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2117            * </p>
2118            *
2119            * @param pageId the primary key of the current wiki page
2120            * @param nodeId the node ID
2121            * @param head the head
2122            * @param parentTitle the parent title
2123            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2124            * @return the previous, current, and next wiki page
2125            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
2126            * @throws SystemException if a system exception occurred
2127            */
2128            public static com.liferay.portlet.wiki.model.WikiPage[] findByN_H_P_PrevAndNext(
2129                    long pageId, long nodeId, boolean head, java.lang.String parentTitle,
2130                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2131                    throws com.liferay.portal.kernel.exception.SystemException,
2132                            com.liferay.portlet.wiki.NoSuchPageException {
2133                    return getPersistence()
2134                                       .findByN_H_P_PrevAndNext(pageId, nodeId, head, parentTitle,
2135                            orderByComparator);
2136            }
2137    
2138            /**
2139            * Returns all the wiki pages where nodeId = &#63; and head = &#63; and status = &#63;.
2140            *
2141            * @param nodeId the node ID
2142            * @param head the head
2143            * @param status the status
2144            * @return the matching wiki pages
2145            * @throws SystemException if a system exception occurred
2146            */
2147            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_H_S(
2148                    long nodeId, boolean head, int status)
2149                    throws com.liferay.portal.kernel.exception.SystemException {
2150                    return getPersistence().findByN_H_S(nodeId, head, status);
2151            }
2152    
2153            /**
2154            * Returns a range of all the wiki pages where nodeId = &#63; and head = &#63; and status = &#63;.
2155            *
2156            * <p>
2157            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2158            * </p>
2159            *
2160            * @param nodeId the node ID
2161            * @param head the head
2162            * @param status the status
2163            * @param start the lower bound of the range of wiki pages
2164            * @param end the upper bound of the range of wiki pages (not inclusive)
2165            * @return the range of matching wiki pages
2166            * @throws SystemException if a system exception occurred
2167            */
2168            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_H_S(
2169                    long nodeId, boolean head, int status, int start, int end)
2170                    throws com.liferay.portal.kernel.exception.SystemException {
2171                    return getPersistence().findByN_H_S(nodeId, head, status, start, end);
2172            }
2173    
2174            /**
2175            * Returns an ordered range of all the wiki pages where nodeId = &#63; and head = &#63; and status = &#63;.
2176            *
2177            * <p>
2178            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2179            * </p>
2180            *
2181            * @param nodeId the node ID
2182            * @param head the head
2183            * @param status the status
2184            * @param start the lower bound of the range of wiki pages
2185            * @param end the upper bound of the range of wiki pages (not inclusive)
2186            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2187            * @return the ordered range of matching wiki pages
2188            * @throws SystemException if a system exception occurred
2189            */
2190            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_H_S(
2191                    long nodeId, boolean head, int status, int start, int end,
2192                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2193                    throws com.liferay.portal.kernel.exception.SystemException {
2194                    return getPersistence()
2195                                       .findByN_H_S(nodeId, head, status, start, end,
2196                            orderByComparator);
2197            }
2198    
2199            /**
2200            * Returns the first wiki page in the ordered set where nodeId = &#63; and head = &#63; and status = &#63;.
2201            *
2202            * <p>
2203            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2204            * </p>
2205            *
2206            * @param nodeId the node ID
2207            * @param head the head
2208            * @param status the status
2209            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2210            * @return the first matching wiki page
2211            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
2212            * @throws SystemException if a system exception occurred
2213            */
2214            public static com.liferay.portlet.wiki.model.WikiPage findByN_H_S_First(
2215                    long nodeId, boolean head, int status,
2216                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2217                    throws com.liferay.portal.kernel.exception.SystemException,
2218                            com.liferay.portlet.wiki.NoSuchPageException {
2219                    return getPersistence()
2220                                       .findByN_H_S_First(nodeId, head, status, orderByComparator);
2221            }
2222    
2223            /**
2224            * Returns the last wiki page in the ordered set where nodeId = &#63; and head = &#63; and status = &#63;.
2225            *
2226            * <p>
2227            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2228            * </p>
2229            *
2230            * @param nodeId the node ID
2231            * @param head the head
2232            * @param status the status
2233            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2234            * @return the last matching wiki page
2235            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
2236            * @throws SystemException if a system exception occurred
2237            */
2238            public static com.liferay.portlet.wiki.model.WikiPage findByN_H_S_Last(
2239                    long nodeId, boolean head, int status,
2240                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2241                    throws com.liferay.portal.kernel.exception.SystemException,
2242                            com.liferay.portlet.wiki.NoSuchPageException {
2243                    return getPersistence()
2244                                       .findByN_H_S_Last(nodeId, head, status, orderByComparator);
2245            }
2246    
2247            /**
2248            * Returns the wiki pages before and after the current wiki page in the ordered set where nodeId = &#63; and head = &#63; and status = &#63;.
2249            *
2250            * <p>
2251            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2252            * </p>
2253            *
2254            * @param pageId the primary key of the current wiki page
2255            * @param nodeId the node ID
2256            * @param head the head
2257            * @param status the status
2258            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2259            * @return the previous, current, and next wiki page
2260            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
2261            * @throws SystemException if a system exception occurred
2262            */
2263            public static com.liferay.portlet.wiki.model.WikiPage[] findByN_H_S_PrevAndNext(
2264                    long pageId, long nodeId, boolean head, int status,
2265                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2266                    throws com.liferay.portal.kernel.exception.SystemException,
2267                            com.liferay.portlet.wiki.NoSuchPageException {
2268                    return getPersistence()
2269                                       .findByN_H_S_PrevAndNext(pageId, nodeId, head, status,
2270                            orderByComparator);
2271            }
2272    
2273            /**
2274            * Returns all the wiki pages where nodeId = &#63; and head = &#63; and parentTitle = &#63; and status = &#63;.
2275            *
2276            * @param nodeId the node ID
2277            * @param head the head
2278            * @param parentTitle the parent title
2279            * @param status the status
2280            * @return the matching wiki pages
2281            * @throws SystemException if a system exception occurred
2282            */
2283            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_H_P_S(
2284                    long nodeId, boolean head, java.lang.String parentTitle, int status)
2285                    throws com.liferay.portal.kernel.exception.SystemException {
2286                    return getPersistence().findByN_H_P_S(nodeId, head, parentTitle, status);
2287            }
2288    
2289            /**
2290            * Returns a range of all the wiki pages where nodeId = &#63; and head = &#63; and parentTitle = &#63; and status = &#63;.
2291            *
2292            * <p>
2293            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2294            * </p>
2295            *
2296            * @param nodeId the node ID
2297            * @param head the head
2298            * @param parentTitle the parent title
2299            * @param status the status
2300            * @param start the lower bound of the range of wiki pages
2301            * @param end the upper bound of the range of wiki pages (not inclusive)
2302            * @return the range of matching wiki pages
2303            * @throws SystemException if a system exception occurred
2304            */
2305            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_H_P_S(
2306                    long nodeId, boolean head, java.lang.String parentTitle, int status,
2307                    int start, int end)
2308                    throws com.liferay.portal.kernel.exception.SystemException {
2309                    return getPersistence()
2310                                       .findByN_H_P_S(nodeId, head, parentTitle, status, start, end);
2311            }
2312    
2313            /**
2314            * Returns an ordered range of all the wiki pages where nodeId = &#63; and head = &#63; and parentTitle = &#63; and status = &#63;.
2315            *
2316            * <p>
2317            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2318            * </p>
2319            *
2320            * @param nodeId the node ID
2321            * @param head the head
2322            * @param parentTitle the parent title
2323            * @param status the status
2324            * @param start the lower bound of the range of wiki pages
2325            * @param end the upper bound of the range of wiki pages (not inclusive)
2326            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2327            * @return the ordered range of matching wiki pages
2328            * @throws SystemException if a system exception occurred
2329            */
2330            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findByN_H_P_S(
2331                    long nodeId, boolean head, java.lang.String parentTitle, int status,
2332                    int start, int end,
2333                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2334                    throws com.liferay.portal.kernel.exception.SystemException {
2335                    return getPersistence()
2336                                       .findByN_H_P_S(nodeId, head, parentTitle, status, start,
2337                            end, orderByComparator);
2338            }
2339    
2340            /**
2341            * Returns the first wiki page in the ordered set where nodeId = &#63; and head = &#63; and parentTitle = &#63; and status = &#63;.
2342            *
2343            * <p>
2344            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2345            * </p>
2346            *
2347            * @param nodeId the node ID
2348            * @param head the head
2349            * @param parentTitle the parent title
2350            * @param status the status
2351            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2352            * @return the first matching wiki page
2353            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
2354            * @throws SystemException if a system exception occurred
2355            */
2356            public static com.liferay.portlet.wiki.model.WikiPage findByN_H_P_S_First(
2357                    long nodeId, boolean head, java.lang.String parentTitle, int status,
2358                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2359                    throws com.liferay.portal.kernel.exception.SystemException,
2360                            com.liferay.portlet.wiki.NoSuchPageException {
2361                    return getPersistence()
2362                                       .findByN_H_P_S_First(nodeId, head, parentTitle, status,
2363                            orderByComparator);
2364            }
2365    
2366            /**
2367            * Returns the last wiki page in the ordered set where nodeId = &#63; and head = &#63; and parentTitle = &#63; and status = &#63;.
2368            *
2369            * <p>
2370            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2371            * </p>
2372            *
2373            * @param nodeId the node ID
2374            * @param head the head
2375            * @param parentTitle the parent title
2376            * @param status the status
2377            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2378            * @return the last matching wiki page
2379            * @throws com.liferay.portlet.wiki.NoSuchPageException if a matching wiki page could not be found
2380            * @throws SystemException if a system exception occurred
2381            */
2382            public static com.liferay.portlet.wiki.model.WikiPage findByN_H_P_S_Last(
2383                    long nodeId, boolean head, java.lang.String parentTitle, int status,
2384                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2385                    throws com.liferay.portal.kernel.exception.SystemException,
2386                            com.liferay.portlet.wiki.NoSuchPageException {
2387                    return getPersistence()
2388                                       .findByN_H_P_S_Last(nodeId, head, parentTitle, status,
2389                            orderByComparator);
2390            }
2391    
2392            /**
2393            * Returns the wiki pages before and after the current wiki page in the ordered set where nodeId = &#63; and head = &#63; and parentTitle = &#63; and status = &#63;.
2394            *
2395            * <p>
2396            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2397            * </p>
2398            *
2399            * @param pageId the primary key of the current wiki page
2400            * @param nodeId the node ID
2401            * @param head the head
2402            * @param parentTitle the parent title
2403            * @param status the status
2404            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2405            * @return the previous, current, and next wiki page
2406            * @throws com.liferay.portlet.wiki.NoSuchPageException if a wiki page with the primary key could not be found
2407            * @throws SystemException if a system exception occurred
2408            */
2409            public static com.liferay.portlet.wiki.model.WikiPage[] findByN_H_P_S_PrevAndNext(
2410                    long pageId, long nodeId, boolean head, java.lang.String parentTitle,
2411                    int status,
2412                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2413                    throws com.liferay.portal.kernel.exception.SystemException,
2414                            com.liferay.portlet.wiki.NoSuchPageException {
2415                    return getPersistence()
2416                                       .findByN_H_P_S_PrevAndNext(pageId, nodeId, head,
2417                            parentTitle, status, orderByComparator);
2418            }
2419    
2420            /**
2421            * Returns all the wiki pages.
2422            *
2423            * @return the wiki pages
2424            * @throws SystemException if a system exception occurred
2425            */
2426            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findAll()
2427                    throws com.liferay.portal.kernel.exception.SystemException {
2428                    return getPersistence().findAll();
2429            }
2430    
2431            /**
2432            * Returns a range of all the wiki pages.
2433            *
2434            * <p>
2435            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2436            * </p>
2437            *
2438            * @param start the lower bound of the range of wiki pages
2439            * @param end the upper bound of the range of wiki pages (not inclusive)
2440            * @return the range of wiki pages
2441            * @throws SystemException if a system exception occurred
2442            */
2443            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findAll(
2444                    int start, int end)
2445                    throws com.liferay.portal.kernel.exception.SystemException {
2446                    return getPersistence().findAll(start, end);
2447            }
2448    
2449            /**
2450            * Returns an ordered range of all the wiki pages.
2451            *
2452            * <p>
2453            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2454            * </p>
2455            *
2456            * @param start the lower bound of the range of wiki pages
2457            * @param end the upper bound of the range of wiki pages (not inclusive)
2458            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2459            * @return the ordered range of wiki pages
2460            * @throws SystemException if a system exception occurred
2461            */
2462            public static java.util.List<com.liferay.portlet.wiki.model.WikiPage> findAll(
2463                    int start, int end,
2464                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2465                    throws com.liferay.portal.kernel.exception.SystemException {
2466                    return getPersistence().findAll(start, end, orderByComparator);
2467            }
2468    
2469            /**
2470            * Removes all the wiki pages where uuid = &#63; from the database.
2471            *
2472            * @param uuid the uuid
2473            * @throws SystemException if a system exception occurred
2474            */
2475            public static void removeByUuid(java.lang.String uuid)
2476                    throws com.liferay.portal.kernel.exception.SystemException {
2477                    getPersistence().removeByUuid(uuid);
2478            }
2479    
2480            /**
2481            * Removes the wiki page where uuid = &#63; and groupId = &#63; from the database.
2482            *
2483            * @param uuid the uuid
2484            * @param groupId the group ID
2485            * @throws SystemException if a system exception occurred
2486            */
2487            public static void removeByUUID_G(java.lang.String uuid, long groupId)
2488                    throws com.liferay.portal.kernel.exception.SystemException,
2489                            com.liferay.portlet.wiki.NoSuchPageException {
2490                    getPersistence().removeByUUID_G(uuid, groupId);
2491            }
2492    
2493            /**
2494            * Removes all the wiki pages where nodeId = &#63; from the database.
2495            *
2496            * @param nodeId the node ID
2497            * @throws SystemException if a system exception occurred
2498            */
2499            public static void removeByNodeId(long nodeId)
2500                    throws com.liferay.portal.kernel.exception.SystemException {
2501                    getPersistence().removeByNodeId(nodeId);
2502            }
2503    
2504            /**
2505            * Removes all the wiki pages where format = &#63; from the database.
2506            *
2507            * @param format the format
2508            * @throws SystemException if a system exception occurred
2509            */
2510            public static void removeByFormat(java.lang.String format)
2511                    throws com.liferay.portal.kernel.exception.SystemException {
2512                    getPersistence().removeByFormat(format);
2513            }
2514    
2515            /**
2516            * Removes all the wiki pages where resourcePrimKey = &#63; and nodeId = &#63; from the database.
2517            *
2518            * @param resourcePrimKey the resource prim key
2519            * @param nodeId the node ID
2520            * @throws SystemException if a system exception occurred
2521            */
2522            public static void removeByR_N(long resourcePrimKey, long nodeId)
2523                    throws com.liferay.portal.kernel.exception.SystemException {
2524                    getPersistence().removeByR_N(resourcePrimKey, nodeId);
2525            }
2526    
2527            /**
2528            * Removes all the wiki pages where nodeId = &#63; and title = &#63; from the database.
2529            *
2530            * @param nodeId the node ID
2531            * @param title the title
2532            * @throws SystemException if a system exception occurred
2533            */
2534            public static void removeByN_T(long nodeId, java.lang.String title)
2535                    throws com.liferay.portal.kernel.exception.SystemException {
2536                    getPersistence().removeByN_T(nodeId, title);
2537            }
2538    
2539            /**
2540            * Removes all the wiki pages where nodeId = &#63; and head = &#63; from the database.
2541            *
2542            * @param nodeId the node ID
2543            * @param head the head
2544            * @throws SystemException if a system exception occurred
2545            */
2546            public static void removeByN_H(long nodeId, boolean head)
2547                    throws com.liferay.portal.kernel.exception.SystemException {
2548                    getPersistence().removeByN_H(nodeId, head);
2549            }
2550    
2551            /**
2552            * Removes all the wiki pages where nodeId = &#63; and parentTitle = &#63; from the database.
2553            *
2554            * @param nodeId the node ID
2555            * @param parentTitle the parent title
2556            * @throws SystemException if a system exception occurred
2557            */
2558            public static void removeByN_P(long nodeId, java.lang.String parentTitle)
2559                    throws com.liferay.portal.kernel.exception.SystemException {
2560                    getPersistence().removeByN_P(nodeId, parentTitle);
2561            }
2562    
2563            /**
2564            * Removes all the wiki pages where nodeId = &#63; and redirectTitle = &#63; from the database.
2565            *
2566            * @param nodeId the node ID
2567            * @param redirectTitle the redirect title
2568            * @throws SystemException if a system exception occurred
2569            */
2570            public static void removeByN_R(long nodeId, java.lang.String redirectTitle)
2571                    throws com.liferay.portal.kernel.exception.SystemException {
2572                    getPersistence().removeByN_R(nodeId, redirectTitle);
2573            }
2574    
2575            /**
2576            * Removes all the wiki pages where nodeId = &#63; and status = &#63; from the database.
2577            *
2578            * @param nodeId the node ID
2579            * @param status the status
2580            * @throws SystemException if a system exception occurred
2581            */
2582            public static void removeByN_S(long nodeId, int status)
2583                    throws com.liferay.portal.kernel.exception.SystemException {
2584                    getPersistence().removeByN_S(nodeId, status);
2585            }
2586    
2587            /**
2588            * Removes the wiki page where resourcePrimKey = &#63; and nodeId = &#63; and version = &#63; from the database.
2589            *
2590            * @param resourcePrimKey the resource prim key
2591            * @param nodeId the node ID
2592            * @param version the version
2593            * @throws SystemException if a system exception occurred
2594            */
2595            public static void removeByR_N_V(long resourcePrimKey, long nodeId,
2596                    double version)
2597                    throws com.liferay.portal.kernel.exception.SystemException,
2598                            com.liferay.portlet.wiki.NoSuchPageException {
2599                    getPersistence().removeByR_N_V(resourcePrimKey, nodeId, version);
2600            }
2601    
2602            /**
2603            * Removes all the wiki pages where resourcePrimKey = &#63; and nodeId = &#63; and status = &#63; from the database.
2604            *
2605            * @param resourcePrimKey the resource prim key
2606            * @param nodeId the node ID
2607            * @param status the status
2608            * @throws SystemException if a system exception occurred
2609            */
2610            public static void removeByR_N_S(long resourcePrimKey, long nodeId,
2611                    int status) throws com.liferay.portal.kernel.exception.SystemException {
2612                    getPersistence().removeByR_N_S(resourcePrimKey, nodeId, status);
2613            }
2614    
2615            /**
2616            * Removes all the wiki pages where userId = &#63; and nodeId = &#63; and status = &#63; from the database.
2617            *
2618            * @param userId the user ID
2619            * @param nodeId the node ID
2620            * @param status the status
2621            * @throws SystemException if a system exception occurred
2622            */
2623            public static void removeByU_N_S(long userId, long nodeId, int status)
2624                    throws com.liferay.portal.kernel.exception.SystemException {
2625                    getPersistence().removeByU_N_S(userId, nodeId, status);
2626            }
2627    
2628            /**
2629            * Removes the wiki page where nodeId = &#63; and title = &#63; and version = &#63; from the database.
2630            *
2631            * @param nodeId the node ID
2632            * @param title the title
2633            * @param version the version
2634            * @throws SystemException if a system exception occurred
2635            */
2636            public static void removeByN_T_V(long nodeId, java.lang.String title,
2637                    double version)
2638                    throws com.liferay.portal.kernel.exception.SystemException,
2639                            com.liferay.portlet.wiki.NoSuchPageException {
2640                    getPersistence().removeByN_T_V(nodeId, title, version);
2641            }
2642    
2643            /**
2644            * Removes all the wiki pages where nodeId = &#63; and title = &#63; and head = &#63; from the database.
2645            *
2646            * @param nodeId the node ID
2647            * @param title the title
2648            * @param head the head
2649            * @throws SystemException if a system exception occurred
2650            */
2651            public static void removeByN_T_H(long nodeId, java.lang.String title,
2652                    boolean head)
2653                    throws com.liferay.portal.kernel.exception.SystemException {
2654                    getPersistence().removeByN_T_H(nodeId, title, head);
2655            }
2656    
2657            /**
2658            * Removes all the wiki pages where nodeId = &#63; and title = &#63; and status = &#63; from the database.
2659            *
2660            * @param nodeId the node ID
2661            * @param title the title
2662            * @param status the status
2663            * @throws SystemException if a system exception occurred
2664            */
2665            public static void removeByN_T_S(long nodeId, java.lang.String title,
2666                    int status) throws com.liferay.portal.kernel.exception.SystemException {
2667                    getPersistence().removeByN_T_S(nodeId, title, status);
2668            }
2669    
2670            /**
2671            * Removes all the wiki pages where nodeId = &#63; and head = &#63; and parentTitle = &#63; from the database.
2672            *
2673            * @param nodeId the node ID
2674            * @param head the head
2675            * @param parentTitle the parent title
2676            * @throws SystemException if a system exception occurred
2677            */
2678            public static void removeByN_H_P(long nodeId, boolean head,
2679                    java.lang.String parentTitle)
2680                    throws com.liferay.portal.kernel.exception.SystemException {
2681                    getPersistence().removeByN_H_P(nodeId, head, parentTitle);
2682            }
2683    
2684            /**
2685            * Removes all the wiki pages where nodeId = &#63; and head = &#63; and status = &#63; from the database.
2686            *
2687            * @param nodeId the node ID
2688            * @param head the head
2689            * @param status the status
2690            * @throws SystemException if a system exception occurred
2691            */
2692            public static void removeByN_H_S(long nodeId, boolean head, int status)
2693                    throws com.liferay.portal.kernel.exception.SystemException {
2694                    getPersistence().removeByN_H_S(nodeId, head, status);
2695            }
2696    
2697            /**
2698            * Removes all the wiki pages where nodeId = &#63; and head = &#63; and parentTitle = &#63; and status = &#63; from the database.
2699            *
2700            * @param nodeId the node ID
2701            * @param head the head
2702            * @param parentTitle the parent title
2703            * @param status the status
2704            * @throws SystemException if a system exception occurred
2705            */
2706            public static void removeByN_H_P_S(long nodeId, boolean head,
2707                    java.lang.String parentTitle, int status)
2708                    throws com.liferay.portal.kernel.exception.SystemException {
2709                    getPersistence().removeByN_H_P_S(nodeId, head, parentTitle, status);
2710            }
2711    
2712            /**
2713            * Removes all the wiki pages from the database.
2714            *
2715            * @throws SystemException if a system exception occurred
2716            */
2717            public static void removeAll()
2718                    throws com.liferay.portal.kernel.exception.SystemException {
2719                    getPersistence().removeAll();
2720            }
2721    
2722            /**
2723            * Returns the number of wiki pages where uuid = &#63;.
2724            *
2725            * @param uuid the uuid
2726            * @return the number of matching wiki pages
2727            * @throws SystemException if a system exception occurred
2728            */
2729            public static int countByUuid(java.lang.String uuid)
2730                    throws com.liferay.portal.kernel.exception.SystemException {
2731                    return getPersistence().countByUuid(uuid);
2732            }
2733    
2734            /**
2735            * Returns the number of wiki pages where uuid = &#63; and groupId = &#63;.
2736            *
2737            * @param uuid the uuid
2738            * @param groupId the group ID
2739            * @return the number of matching wiki pages
2740            * @throws SystemException if a system exception occurred
2741            */
2742            public static int countByUUID_G(java.lang.String uuid, long groupId)
2743                    throws com.liferay.portal.kernel.exception.SystemException {
2744                    return getPersistence().countByUUID_G(uuid, groupId);
2745            }
2746    
2747            /**
2748            * Returns the number of wiki pages where nodeId = &#63;.
2749            *
2750            * @param nodeId the node ID
2751            * @return the number of matching wiki pages
2752            * @throws SystemException if a system exception occurred
2753            */
2754            public static int countByNodeId(long nodeId)
2755                    throws com.liferay.portal.kernel.exception.SystemException {
2756                    return getPersistence().countByNodeId(nodeId);
2757            }
2758    
2759            /**
2760            * Returns the number of wiki pages where format = &#63;.
2761            *
2762            * @param format the format
2763            * @return the number of matching wiki pages
2764            * @throws SystemException if a system exception occurred
2765            */
2766            public static int countByFormat(java.lang.String format)
2767                    throws com.liferay.portal.kernel.exception.SystemException {
2768                    return getPersistence().countByFormat(format);
2769            }
2770    
2771            /**
2772            * Returns the number of wiki pages where resourcePrimKey = &#63; and nodeId = &#63;.
2773            *
2774            * @param resourcePrimKey the resource prim key
2775            * @param nodeId the node ID
2776            * @return the number of matching wiki pages
2777            * @throws SystemException if a system exception occurred
2778            */
2779            public static int countByR_N(long resourcePrimKey, long nodeId)
2780                    throws com.liferay.portal.kernel.exception.SystemException {
2781                    return getPersistence().countByR_N(resourcePrimKey, nodeId);
2782            }
2783    
2784            /**
2785            * Returns the number of wiki pages where nodeId = &#63; and title = &#63;.
2786            *
2787            * @param nodeId the node ID
2788            * @param title the title
2789            * @return the number of matching wiki pages
2790            * @throws SystemException if a system exception occurred
2791            */
2792            public static int countByN_T(long nodeId, java.lang.String title)
2793                    throws com.liferay.portal.kernel.exception.SystemException {
2794                    return getPersistence().countByN_T(nodeId, title);
2795            }
2796    
2797            /**
2798            * Returns the number of wiki pages where nodeId = &#63; and head = &#63;.
2799            *
2800            * @param nodeId the node ID
2801            * @param head the head
2802            * @return the number of matching wiki pages
2803            * @throws SystemException if a system exception occurred
2804            */
2805            public static int countByN_H(long nodeId, boolean head)
2806                    throws com.liferay.portal.kernel.exception.SystemException {
2807                    return getPersistence().countByN_H(nodeId, head);
2808            }
2809    
2810            /**
2811            * Returns the number of wiki pages where nodeId = &#63; and parentTitle = &#63;.
2812            *
2813            * @param nodeId the node ID
2814            * @param parentTitle the parent title
2815            * @return the number of matching wiki pages
2816            * @throws SystemException if a system exception occurred
2817            */
2818            public static int countByN_P(long nodeId, java.lang.String parentTitle)
2819                    throws com.liferay.portal.kernel.exception.SystemException {
2820                    return getPersistence().countByN_P(nodeId, parentTitle);
2821            }
2822    
2823            /**
2824            * Returns the number of wiki pages where nodeId = &#63; and redirectTitle = &#63;.
2825            *
2826            * @param nodeId the node ID
2827            * @param redirectTitle the redirect title
2828            * @return the number of matching wiki pages
2829            * @throws SystemException if a system exception occurred
2830            */
2831            public static int countByN_R(long nodeId, java.lang.String redirectTitle)
2832                    throws com.liferay.portal.kernel.exception.SystemException {
2833                    return getPersistence().countByN_R(nodeId, redirectTitle);
2834            }
2835    
2836            /**
2837            * Returns the number of wiki pages where nodeId = &#63; and status = &#63;.
2838            *
2839            * @param nodeId the node ID
2840            * @param status the status
2841            * @return the number of matching wiki pages
2842            * @throws SystemException if a system exception occurred
2843            */
2844            public static int countByN_S(long nodeId, int status)
2845                    throws com.liferay.portal.kernel.exception.SystemException {
2846                    return getPersistence().countByN_S(nodeId, status);
2847            }
2848    
2849            /**
2850            * Returns the number of wiki pages where resourcePrimKey = &#63; and nodeId = &#63; and version = &#63;.
2851            *
2852            * @param resourcePrimKey the resource prim key
2853            * @param nodeId the node ID
2854            * @param version the version
2855            * @return the number of matching wiki pages
2856            * @throws SystemException if a system exception occurred
2857            */
2858            public static int countByR_N_V(long resourcePrimKey, long nodeId,
2859                    double version)
2860                    throws com.liferay.portal.kernel.exception.SystemException {
2861                    return getPersistence().countByR_N_V(resourcePrimKey, nodeId, version);
2862            }
2863    
2864            /**
2865            * Returns the number of wiki pages where resourcePrimKey = &#63; and nodeId = &#63; and status = &#63;.
2866            *
2867            * @param resourcePrimKey the resource prim key
2868            * @param nodeId the node ID
2869            * @param status the status
2870            * @return the number of matching wiki pages
2871            * @throws SystemException if a system exception occurred
2872            */
2873            public static int countByR_N_S(long resourcePrimKey, long nodeId, int status)
2874                    throws com.liferay.portal.kernel.exception.SystemException {
2875                    return getPersistence().countByR_N_S(resourcePrimKey, nodeId, status);
2876            }
2877    
2878            /**
2879            * Returns the number of wiki pages where userId = &#63; and nodeId = &#63; and status = &#63;.
2880            *
2881            * @param userId the user ID
2882            * @param nodeId the node ID
2883            * @param status the status
2884            * @return the number of matching wiki pages
2885            * @throws SystemException if a system exception occurred
2886            */
2887            public static int countByU_N_S(long userId, long nodeId, int status)
2888                    throws com.liferay.portal.kernel.exception.SystemException {
2889                    return getPersistence().countByU_N_S(userId, nodeId, status);
2890            }
2891    
2892            /**
2893            * Returns the number of wiki pages where nodeId = &#63; and title = &#63; and version = &#63;.
2894            *
2895            * @param nodeId the node ID
2896            * @param title the title
2897            * @param version the version
2898            * @return the number of matching wiki pages
2899            * @throws SystemException if a system exception occurred
2900            */
2901            public static int countByN_T_V(long nodeId, java.lang.String title,
2902                    double version)
2903                    throws com.liferay.portal.kernel.exception.SystemException {
2904                    return getPersistence().countByN_T_V(nodeId, title, version);
2905            }
2906    
2907            /**
2908            * Returns the number of wiki pages where nodeId = &#63; and title = &#63; and head = &#63;.
2909            *
2910            * @param nodeId the node ID
2911            * @param title the title
2912            * @param head the head
2913            * @return the number of matching wiki pages
2914            * @throws SystemException if a system exception occurred
2915            */
2916            public static int countByN_T_H(long nodeId, java.lang.String title,
2917                    boolean head)
2918                    throws com.liferay.portal.kernel.exception.SystemException {
2919                    return getPersistence().countByN_T_H(nodeId, title, head);
2920            }
2921    
2922            /**
2923            * Returns the number of wiki pages where nodeId = &#63; and title = &#63; and status = &#63;.
2924            *
2925            * @param nodeId the node ID
2926            * @param title the title
2927            * @param status the status
2928            * @return the number of matching wiki pages
2929            * @throws SystemException if a system exception occurred
2930            */
2931            public static int countByN_T_S(long nodeId, java.lang.String title,
2932                    int status) throws com.liferay.portal.kernel.exception.SystemException {
2933                    return getPersistence().countByN_T_S(nodeId, title, status);
2934            }
2935    
2936            /**
2937            * Returns the number of wiki pages where nodeId = &#63; and head = &#63; and parentTitle = &#63;.
2938            *
2939            * @param nodeId the node ID
2940            * @param head the head
2941            * @param parentTitle the parent title
2942            * @return the number of matching wiki pages
2943            * @throws SystemException if a system exception occurred
2944            */
2945            public static int countByN_H_P(long nodeId, boolean head,
2946                    java.lang.String parentTitle)
2947                    throws com.liferay.portal.kernel.exception.SystemException {
2948                    return getPersistence().countByN_H_P(nodeId, head, parentTitle);
2949            }
2950    
2951            /**
2952            * Returns the number of wiki pages where nodeId = &#63; and head = &#63; and status = &#63;.
2953            *
2954            * @param nodeId the node ID
2955            * @param head the head
2956            * @param status the status
2957            * @return the number of matching wiki pages
2958            * @throws SystemException if a system exception occurred
2959            */
2960            public static int countByN_H_S(long nodeId, boolean head, int status)
2961                    throws com.liferay.portal.kernel.exception.SystemException {
2962                    return getPersistence().countByN_H_S(nodeId, head, status);
2963            }
2964    
2965            /**
2966            * Returns the number of wiki pages where nodeId = &#63; and head = &#63; and parentTitle = &#63; and status = &#63;.
2967            *
2968            * @param nodeId the node ID
2969            * @param head the head
2970            * @param parentTitle the parent title
2971            * @param status the status
2972            * @return the number of matching wiki pages
2973            * @throws SystemException if a system exception occurred
2974            */
2975            public static int countByN_H_P_S(long nodeId, boolean head,
2976                    java.lang.String parentTitle, int status)
2977                    throws com.liferay.portal.kernel.exception.SystemException {
2978                    return getPersistence().countByN_H_P_S(nodeId, head, parentTitle, status);
2979            }
2980    
2981            /**
2982            * Returns the number of wiki pages.
2983            *
2984            * @return the number of wiki pages
2985            * @throws SystemException if a system exception occurred
2986            */
2987            public static int countAll()
2988                    throws com.liferay.portal.kernel.exception.SystemException {
2989                    return getPersistence().countAll();
2990            }
2991    
2992            public static WikiPagePersistence getPersistence() {
2993                    if (_persistence == null) {
2994                            _persistence = (WikiPagePersistence)PortalBeanLocatorUtil.locate(WikiPagePersistence.class.getName());
2995    
2996                            ReferenceRegistry.registerReference(WikiPageUtil.class,
2997                                    "_persistence");
2998                    }
2999    
3000                    return _persistence;
3001            }
3002    
3003            public void setPersistence(WikiPagePersistence persistence) {
3004                    _persistence = persistence;
3005    
3006                    ReferenceRegistry.registerReference(WikiPageUtil.class, "_persistence");
3007            }
3008    
3009            private static WikiPagePersistence _persistence;
3010    }