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