001    /**
002     * Copyright (c) 2000-present 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.portal.service.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
020    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
021    import com.liferay.portal.kernel.util.OrderByComparator;
022    import com.liferay.portal.kernel.util.ReferenceRegistry;
023    import com.liferay.portal.model.MembershipRequest;
024    import com.liferay.portal.service.ServiceContext;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the membership request service. This utility wraps {@link com.liferay.portal.service.persistence.impl.MembershipRequestPersistenceImpl} 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 MembershipRequestPersistence
037     * @see com.liferay.portal.service.persistence.impl.MembershipRequestPersistenceImpl
038     * @generated
039     */
040    @ProviderType
041    public class MembershipRequestUtil {
042            /*
043             * NOTE FOR DEVELOPERS:
044             *
045             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
046             */
047    
048            /**
049             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
050             */
051            public static void clearCache() {
052                    getPersistence().clearCache();
053            }
054    
055            /**
056             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
057             */
058            public static void clearCache(MembershipRequest membershipRequest) {
059                    getPersistence().clearCache(membershipRequest);
060            }
061    
062            /**
063             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
064             */
065            public static long countWithDynamicQuery(DynamicQuery dynamicQuery) {
066                    return getPersistence().countWithDynamicQuery(dynamicQuery);
067            }
068    
069            /**
070             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
071             */
072            public static List<MembershipRequest> findWithDynamicQuery(
073                    DynamicQuery dynamicQuery) {
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<MembershipRequest> findWithDynamicQuery(
081                    DynamicQuery dynamicQuery, int start, int end) {
082                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
083            }
084    
085            /**
086             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
087             */
088            public static List<MembershipRequest> findWithDynamicQuery(
089                    DynamicQuery dynamicQuery, int start, int end,
090                    OrderByComparator<MembershipRequest> orderByComparator) {
091                    return getPersistence()
092                                       .findWithDynamicQuery(dynamicQuery, start, end,
093                            orderByComparator);
094            }
095    
096            /**
097             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
098             */
099            public static MembershipRequest update(MembershipRequest membershipRequest) {
100                    return getPersistence().update(membershipRequest);
101            }
102    
103            /**
104             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
105             */
106            public static MembershipRequest update(
107                    MembershipRequest membershipRequest, ServiceContext serviceContext) {
108                    return getPersistence().update(membershipRequest, serviceContext);
109            }
110    
111            /**
112            * Returns all the membership requests where groupId = &#63;.
113            *
114            * @param groupId the group ID
115            * @return the matching membership requests
116            */
117            public static List<MembershipRequest> findByGroupId(long groupId) {
118                    return getPersistence().findByGroupId(groupId);
119            }
120    
121            /**
122            * Returns a range of all the membership requests where groupId = &#63;.
123            *
124            * <p>
125            * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link MembershipRequestModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
126            * </p>
127            *
128            * @param groupId the group ID
129            * @param start the lower bound of the range of membership requests
130            * @param end the upper bound of the range of membership requests (not inclusive)
131            * @return the range of matching membership requests
132            */
133            public static List<MembershipRequest> findByGroupId(long groupId,
134                    int start, int end) {
135                    return getPersistence().findByGroupId(groupId, start, end);
136            }
137    
138            /**
139            * Returns an ordered range of all the membership requests where groupId = &#63;.
140            *
141            * <p>
142            * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link MembershipRequestModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
143            * </p>
144            *
145            * @param groupId the group ID
146            * @param start the lower bound of the range of membership requests
147            * @param end the upper bound of the range of membership requests (not inclusive)
148            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
149            * @return the ordered range of matching membership requests
150            */
151            public static List<MembershipRequest> findByGroupId(long groupId,
152                    int start, int end,
153                    OrderByComparator<MembershipRequest> orderByComparator) {
154                    return getPersistence()
155                                       .findByGroupId(groupId, start, end, orderByComparator);
156            }
157    
158            /**
159            * Returns an ordered range of all the membership requests where groupId = &#63;.
160            *
161            * <p>
162            * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link MembershipRequestModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
163            * </p>
164            *
165            * @param groupId the group ID
166            * @param start the lower bound of the range of membership requests
167            * @param end the upper bound of the range of membership requests (not inclusive)
168            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
169            * @param retrieveFromCache whether to retrieve from the finder cache
170            * @return the ordered range of matching membership requests
171            */
172            public static List<MembershipRequest> findByGroupId(long groupId,
173                    int start, int end,
174                    OrderByComparator<MembershipRequest> orderByComparator,
175                    boolean retrieveFromCache) {
176                    return getPersistence()
177                                       .findByGroupId(groupId, start, end, orderByComparator,
178                            retrieveFromCache);
179            }
180    
181            /**
182            * Returns the first membership request in the ordered set where groupId = &#63;.
183            *
184            * @param groupId the group ID
185            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
186            * @return the first matching membership request
187            * @throws NoSuchMembershipRequestException if a matching membership request could not be found
188            */
189            public static MembershipRequest findByGroupId_First(long groupId,
190                    OrderByComparator<MembershipRequest> orderByComparator)
191                    throws com.liferay.portal.exception.NoSuchMembershipRequestException {
192                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
193            }
194    
195            /**
196            * Returns the first membership request in the ordered set where groupId = &#63;.
197            *
198            * @param groupId the group ID
199            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
200            * @return the first matching membership request, or <code>null</code> if a matching membership request could not be found
201            */
202            public static MembershipRequest fetchByGroupId_First(long groupId,
203                    OrderByComparator<MembershipRequest> orderByComparator) {
204                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
205            }
206    
207            /**
208            * Returns the last membership request in the ordered set where groupId = &#63;.
209            *
210            * @param groupId the group ID
211            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
212            * @return the last matching membership request
213            * @throws NoSuchMembershipRequestException if a matching membership request could not be found
214            */
215            public static MembershipRequest findByGroupId_Last(long groupId,
216                    OrderByComparator<MembershipRequest> orderByComparator)
217                    throws com.liferay.portal.exception.NoSuchMembershipRequestException {
218                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
219            }
220    
221            /**
222            * Returns the last membership request in the ordered set where groupId = &#63;.
223            *
224            * @param groupId the group ID
225            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
226            * @return the last matching membership request, or <code>null</code> if a matching membership request could not be found
227            */
228            public static MembershipRequest fetchByGroupId_Last(long groupId,
229                    OrderByComparator<MembershipRequest> orderByComparator) {
230                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
231            }
232    
233            /**
234            * Returns the membership requests before and after the current membership request in the ordered set where groupId = &#63;.
235            *
236            * @param membershipRequestId the primary key of the current membership request
237            * @param groupId the group ID
238            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
239            * @return the previous, current, and next membership request
240            * @throws NoSuchMembershipRequestException if a membership request with the primary key could not be found
241            */
242            public static MembershipRequest[] findByGroupId_PrevAndNext(
243                    long membershipRequestId, long groupId,
244                    OrderByComparator<MembershipRequest> orderByComparator)
245                    throws com.liferay.portal.exception.NoSuchMembershipRequestException {
246                    return getPersistence()
247                                       .findByGroupId_PrevAndNext(membershipRequestId, groupId,
248                            orderByComparator);
249            }
250    
251            /**
252            * Removes all the membership requests where groupId = &#63; from the database.
253            *
254            * @param groupId the group ID
255            */
256            public static void removeByGroupId(long groupId) {
257                    getPersistence().removeByGroupId(groupId);
258            }
259    
260            /**
261            * Returns the number of membership requests where groupId = &#63;.
262            *
263            * @param groupId the group ID
264            * @return the number of matching membership requests
265            */
266            public static int countByGroupId(long groupId) {
267                    return getPersistence().countByGroupId(groupId);
268            }
269    
270            /**
271            * Returns all the membership requests where userId = &#63;.
272            *
273            * @param userId the user ID
274            * @return the matching membership requests
275            */
276            public static List<MembershipRequest> findByUserId(long userId) {
277                    return getPersistence().findByUserId(userId);
278            }
279    
280            /**
281            * Returns a range of all the membership requests where userId = &#63;.
282            *
283            * <p>
284            * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link MembershipRequestModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
285            * </p>
286            *
287            * @param userId the user ID
288            * @param start the lower bound of the range of membership requests
289            * @param end the upper bound of the range of membership requests (not inclusive)
290            * @return the range of matching membership requests
291            */
292            public static List<MembershipRequest> findByUserId(long userId, int start,
293                    int end) {
294                    return getPersistence().findByUserId(userId, start, end);
295            }
296    
297            /**
298            * Returns an ordered range of all the membership requests where userId = &#63;.
299            *
300            * <p>
301            * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link MembershipRequestModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
302            * </p>
303            *
304            * @param userId the user ID
305            * @param start the lower bound of the range of membership requests
306            * @param end the upper bound of the range of membership requests (not inclusive)
307            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
308            * @return the ordered range of matching membership requests
309            */
310            public static List<MembershipRequest> findByUserId(long userId, int start,
311                    int end, OrderByComparator<MembershipRequest> orderByComparator) {
312                    return getPersistence()
313                                       .findByUserId(userId, start, end, orderByComparator);
314            }
315    
316            /**
317            * Returns an ordered range of all the membership requests where userId = &#63;.
318            *
319            * <p>
320            * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link MembershipRequestModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
321            * </p>
322            *
323            * @param userId the user ID
324            * @param start the lower bound of the range of membership requests
325            * @param end the upper bound of the range of membership requests (not inclusive)
326            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
327            * @param retrieveFromCache whether to retrieve from the finder cache
328            * @return the ordered range of matching membership requests
329            */
330            public static List<MembershipRequest> findByUserId(long userId, int start,
331                    int end, OrderByComparator<MembershipRequest> orderByComparator,
332                    boolean retrieveFromCache) {
333                    return getPersistence()
334                                       .findByUserId(userId, start, end, orderByComparator,
335                            retrieveFromCache);
336            }
337    
338            /**
339            * Returns the first membership request in the ordered set where userId = &#63;.
340            *
341            * @param userId the user ID
342            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
343            * @return the first matching membership request
344            * @throws NoSuchMembershipRequestException if a matching membership request could not be found
345            */
346            public static MembershipRequest findByUserId_First(long userId,
347                    OrderByComparator<MembershipRequest> orderByComparator)
348                    throws com.liferay.portal.exception.NoSuchMembershipRequestException {
349                    return getPersistence().findByUserId_First(userId, orderByComparator);
350            }
351    
352            /**
353            * Returns the first membership request in the ordered set where userId = &#63;.
354            *
355            * @param userId the user ID
356            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
357            * @return the first matching membership request, or <code>null</code> if a matching membership request could not be found
358            */
359            public static MembershipRequest fetchByUserId_First(long userId,
360                    OrderByComparator<MembershipRequest> orderByComparator) {
361                    return getPersistence().fetchByUserId_First(userId, orderByComparator);
362            }
363    
364            /**
365            * Returns the last membership request in the ordered set where userId = &#63;.
366            *
367            * @param userId the user ID
368            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
369            * @return the last matching membership request
370            * @throws NoSuchMembershipRequestException if a matching membership request could not be found
371            */
372            public static MembershipRequest findByUserId_Last(long userId,
373                    OrderByComparator<MembershipRequest> orderByComparator)
374                    throws com.liferay.portal.exception.NoSuchMembershipRequestException {
375                    return getPersistence().findByUserId_Last(userId, orderByComparator);
376            }
377    
378            /**
379            * Returns the last membership request in the ordered set where userId = &#63;.
380            *
381            * @param userId the user ID
382            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
383            * @return the last matching membership request, or <code>null</code> if a matching membership request could not be found
384            */
385            public static MembershipRequest fetchByUserId_Last(long userId,
386                    OrderByComparator<MembershipRequest> orderByComparator) {
387                    return getPersistence().fetchByUserId_Last(userId, orderByComparator);
388            }
389    
390            /**
391            * Returns the membership requests before and after the current membership request in the ordered set where userId = &#63;.
392            *
393            * @param membershipRequestId the primary key of the current membership request
394            * @param userId the user ID
395            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
396            * @return the previous, current, and next membership request
397            * @throws NoSuchMembershipRequestException if a membership request with the primary key could not be found
398            */
399            public static MembershipRequest[] findByUserId_PrevAndNext(
400                    long membershipRequestId, long userId,
401                    OrderByComparator<MembershipRequest> orderByComparator)
402                    throws com.liferay.portal.exception.NoSuchMembershipRequestException {
403                    return getPersistence()
404                                       .findByUserId_PrevAndNext(membershipRequestId, userId,
405                            orderByComparator);
406            }
407    
408            /**
409            * Removes all the membership requests where userId = &#63; from the database.
410            *
411            * @param userId the user ID
412            */
413            public static void removeByUserId(long userId) {
414                    getPersistence().removeByUserId(userId);
415            }
416    
417            /**
418            * Returns the number of membership requests where userId = &#63;.
419            *
420            * @param userId the user ID
421            * @return the number of matching membership requests
422            */
423            public static int countByUserId(long userId) {
424                    return getPersistence().countByUserId(userId);
425            }
426    
427            /**
428            * Returns all the membership requests where groupId = &#63; and statusId = &#63;.
429            *
430            * @param groupId the group ID
431            * @param statusId the status ID
432            * @return the matching membership requests
433            */
434            public static List<MembershipRequest> findByG_S(long groupId, long statusId) {
435                    return getPersistence().findByG_S(groupId, statusId);
436            }
437    
438            /**
439            * Returns a range of all the membership requests where groupId = &#63; and statusId = &#63;.
440            *
441            * <p>
442            * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link MembershipRequestModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
443            * </p>
444            *
445            * @param groupId the group ID
446            * @param statusId the status ID
447            * @param start the lower bound of the range of membership requests
448            * @param end the upper bound of the range of membership requests (not inclusive)
449            * @return the range of matching membership requests
450            */
451            public static List<MembershipRequest> findByG_S(long groupId,
452                    long statusId, int start, int end) {
453                    return getPersistence().findByG_S(groupId, statusId, start, end);
454            }
455    
456            /**
457            * Returns an ordered range of all the membership requests where groupId = &#63; and statusId = &#63;.
458            *
459            * <p>
460            * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link MembershipRequestModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
461            * </p>
462            *
463            * @param groupId the group ID
464            * @param statusId the status ID
465            * @param start the lower bound of the range of membership requests
466            * @param end the upper bound of the range of membership requests (not inclusive)
467            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
468            * @return the ordered range of matching membership requests
469            */
470            public static List<MembershipRequest> findByG_S(long groupId,
471                    long statusId, int start, int end,
472                    OrderByComparator<MembershipRequest> orderByComparator) {
473                    return getPersistence()
474                                       .findByG_S(groupId, statusId, start, end, orderByComparator);
475            }
476    
477            /**
478            * Returns an ordered range of all the membership requests where groupId = &#63; and statusId = &#63;.
479            *
480            * <p>
481            * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link MembershipRequestModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
482            * </p>
483            *
484            * @param groupId the group ID
485            * @param statusId the status ID
486            * @param start the lower bound of the range of membership requests
487            * @param end the upper bound of the range of membership requests (not inclusive)
488            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
489            * @param retrieveFromCache whether to retrieve from the finder cache
490            * @return the ordered range of matching membership requests
491            */
492            public static List<MembershipRequest> findByG_S(long groupId,
493                    long statusId, int start, int end,
494                    OrderByComparator<MembershipRequest> orderByComparator,
495                    boolean retrieveFromCache) {
496                    return getPersistence()
497                                       .findByG_S(groupId, statusId, start, end, orderByComparator,
498                            retrieveFromCache);
499            }
500    
501            /**
502            * Returns the first membership request in the ordered set where groupId = &#63; and statusId = &#63;.
503            *
504            * @param groupId the group ID
505            * @param statusId the status ID
506            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
507            * @return the first matching membership request
508            * @throws NoSuchMembershipRequestException if a matching membership request could not be found
509            */
510            public static MembershipRequest findByG_S_First(long groupId,
511                    long statusId, OrderByComparator<MembershipRequest> orderByComparator)
512                    throws com.liferay.portal.exception.NoSuchMembershipRequestException {
513                    return getPersistence()
514                                       .findByG_S_First(groupId, statusId, orderByComparator);
515            }
516    
517            /**
518            * Returns the first membership request in the ordered set where groupId = &#63; and statusId = &#63;.
519            *
520            * @param groupId the group ID
521            * @param statusId the status ID
522            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
523            * @return the first matching membership request, or <code>null</code> if a matching membership request could not be found
524            */
525            public static MembershipRequest fetchByG_S_First(long groupId,
526                    long statusId, OrderByComparator<MembershipRequest> orderByComparator) {
527                    return getPersistence()
528                                       .fetchByG_S_First(groupId, statusId, orderByComparator);
529            }
530    
531            /**
532            * Returns the last membership request in the ordered set where groupId = &#63; and statusId = &#63;.
533            *
534            * @param groupId the group ID
535            * @param statusId the status ID
536            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
537            * @return the last matching membership request
538            * @throws NoSuchMembershipRequestException if a matching membership request could not be found
539            */
540            public static MembershipRequest findByG_S_Last(long groupId, long statusId,
541                    OrderByComparator<MembershipRequest> orderByComparator)
542                    throws com.liferay.portal.exception.NoSuchMembershipRequestException {
543                    return getPersistence()
544                                       .findByG_S_Last(groupId, statusId, orderByComparator);
545            }
546    
547            /**
548            * Returns the last membership request in the ordered set where groupId = &#63; and statusId = &#63;.
549            *
550            * @param groupId the group ID
551            * @param statusId the status ID
552            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
553            * @return the last matching membership request, or <code>null</code> if a matching membership request could not be found
554            */
555            public static MembershipRequest fetchByG_S_Last(long groupId,
556                    long statusId, OrderByComparator<MembershipRequest> orderByComparator) {
557                    return getPersistence()
558                                       .fetchByG_S_Last(groupId, statusId, orderByComparator);
559            }
560    
561            /**
562            * Returns the membership requests before and after the current membership request in the ordered set where groupId = &#63; and statusId = &#63;.
563            *
564            * @param membershipRequestId the primary key of the current membership request
565            * @param groupId the group ID
566            * @param statusId the status ID
567            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
568            * @return the previous, current, and next membership request
569            * @throws NoSuchMembershipRequestException if a membership request with the primary key could not be found
570            */
571            public static MembershipRequest[] findByG_S_PrevAndNext(
572                    long membershipRequestId, long groupId, long statusId,
573                    OrderByComparator<MembershipRequest> orderByComparator)
574                    throws com.liferay.portal.exception.NoSuchMembershipRequestException {
575                    return getPersistence()
576                                       .findByG_S_PrevAndNext(membershipRequestId, groupId,
577                            statusId, orderByComparator);
578            }
579    
580            /**
581            * Removes all the membership requests where groupId = &#63; and statusId = &#63; from the database.
582            *
583            * @param groupId the group ID
584            * @param statusId the status ID
585            */
586            public static void removeByG_S(long groupId, long statusId) {
587                    getPersistence().removeByG_S(groupId, statusId);
588            }
589    
590            /**
591            * Returns the number of membership requests where groupId = &#63; and statusId = &#63;.
592            *
593            * @param groupId the group ID
594            * @param statusId the status ID
595            * @return the number of matching membership requests
596            */
597            public static int countByG_S(long groupId, long statusId) {
598                    return getPersistence().countByG_S(groupId, statusId);
599            }
600    
601            /**
602            * Returns all the membership requests where groupId = &#63; and userId = &#63; and statusId = &#63;.
603            *
604            * @param groupId the group ID
605            * @param userId the user ID
606            * @param statusId the status ID
607            * @return the matching membership requests
608            */
609            public static List<MembershipRequest> findByG_U_S(long groupId,
610                    long userId, long statusId) {
611                    return getPersistence().findByG_U_S(groupId, userId, statusId);
612            }
613    
614            /**
615            * Returns a range of all the membership requests where groupId = &#63; and userId = &#63; and statusId = &#63;.
616            *
617            * <p>
618            * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link MembershipRequestModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
619            * </p>
620            *
621            * @param groupId the group ID
622            * @param userId the user ID
623            * @param statusId the status ID
624            * @param start the lower bound of the range of membership requests
625            * @param end the upper bound of the range of membership requests (not inclusive)
626            * @return the range of matching membership requests
627            */
628            public static List<MembershipRequest> findByG_U_S(long groupId,
629                    long userId, long statusId, int start, int end) {
630                    return getPersistence()
631                                       .findByG_U_S(groupId, userId, statusId, start, end);
632            }
633    
634            /**
635            * Returns an ordered range of all the membership requests where groupId = &#63; and userId = &#63; and statusId = &#63;.
636            *
637            * <p>
638            * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link MembershipRequestModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
639            * </p>
640            *
641            * @param groupId the group ID
642            * @param userId the user ID
643            * @param statusId the status ID
644            * @param start the lower bound of the range of membership requests
645            * @param end the upper bound of the range of membership requests (not inclusive)
646            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
647            * @return the ordered range of matching membership requests
648            */
649            public static List<MembershipRequest> findByG_U_S(long groupId,
650                    long userId, long statusId, int start, int end,
651                    OrderByComparator<MembershipRequest> orderByComparator) {
652                    return getPersistence()
653                                       .findByG_U_S(groupId, userId, statusId, start, end,
654                            orderByComparator);
655            }
656    
657            /**
658            * Returns an ordered range of all the membership requests where groupId = &#63; and userId = &#63; and statusId = &#63;.
659            *
660            * <p>
661            * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link MembershipRequestModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
662            * </p>
663            *
664            * @param groupId the group ID
665            * @param userId the user ID
666            * @param statusId the status ID
667            * @param start the lower bound of the range of membership requests
668            * @param end the upper bound of the range of membership requests (not inclusive)
669            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
670            * @param retrieveFromCache whether to retrieve from the finder cache
671            * @return the ordered range of matching membership requests
672            */
673            public static List<MembershipRequest> findByG_U_S(long groupId,
674                    long userId, long statusId, int start, int end,
675                    OrderByComparator<MembershipRequest> orderByComparator,
676                    boolean retrieveFromCache) {
677                    return getPersistence()
678                                       .findByG_U_S(groupId, userId, statusId, start, end,
679                            orderByComparator, retrieveFromCache);
680            }
681    
682            /**
683            * Returns the first membership request in the ordered set where groupId = &#63; and userId = &#63; and statusId = &#63;.
684            *
685            * @param groupId the group ID
686            * @param userId the user ID
687            * @param statusId the status ID
688            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
689            * @return the first matching membership request
690            * @throws NoSuchMembershipRequestException if a matching membership request could not be found
691            */
692            public static MembershipRequest findByG_U_S_First(long groupId,
693                    long userId, long statusId,
694                    OrderByComparator<MembershipRequest> orderByComparator)
695                    throws com.liferay.portal.exception.NoSuchMembershipRequestException {
696                    return getPersistence()
697                                       .findByG_U_S_First(groupId, userId, statusId,
698                            orderByComparator);
699            }
700    
701            /**
702            * Returns the first membership request in the ordered set where groupId = &#63; and userId = &#63; and statusId = &#63;.
703            *
704            * @param groupId the group ID
705            * @param userId the user ID
706            * @param statusId the status ID
707            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
708            * @return the first matching membership request, or <code>null</code> if a matching membership request could not be found
709            */
710            public static MembershipRequest fetchByG_U_S_First(long groupId,
711                    long userId, long statusId,
712                    OrderByComparator<MembershipRequest> orderByComparator) {
713                    return getPersistence()
714                                       .fetchByG_U_S_First(groupId, userId, statusId,
715                            orderByComparator);
716            }
717    
718            /**
719            * Returns the last membership request in the ordered set where groupId = &#63; and userId = &#63; and statusId = &#63;.
720            *
721            * @param groupId the group ID
722            * @param userId the user ID
723            * @param statusId the status ID
724            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
725            * @return the last matching membership request
726            * @throws NoSuchMembershipRequestException if a matching membership request could not be found
727            */
728            public static MembershipRequest findByG_U_S_Last(long groupId, long userId,
729                    long statusId, OrderByComparator<MembershipRequest> orderByComparator)
730                    throws com.liferay.portal.exception.NoSuchMembershipRequestException {
731                    return getPersistence()
732                                       .findByG_U_S_Last(groupId, userId, statusId,
733                            orderByComparator);
734            }
735    
736            /**
737            * Returns the last membership request in the ordered set where groupId = &#63; and userId = &#63; and statusId = &#63;.
738            *
739            * @param groupId the group ID
740            * @param userId the user ID
741            * @param statusId the status ID
742            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
743            * @return the last matching membership request, or <code>null</code> if a matching membership request could not be found
744            */
745            public static MembershipRequest fetchByG_U_S_Last(long groupId,
746                    long userId, long statusId,
747                    OrderByComparator<MembershipRequest> orderByComparator) {
748                    return getPersistence()
749                                       .fetchByG_U_S_Last(groupId, userId, statusId,
750                            orderByComparator);
751            }
752    
753            /**
754            * Returns the membership requests before and after the current membership request in the ordered set where groupId = &#63; and userId = &#63; and statusId = &#63;.
755            *
756            * @param membershipRequestId the primary key of the current membership request
757            * @param groupId the group ID
758            * @param userId the user ID
759            * @param statusId the status ID
760            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
761            * @return the previous, current, and next membership request
762            * @throws NoSuchMembershipRequestException if a membership request with the primary key could not be found
763            */
764            public static MembershipRequest[] findByG_U_S_PrevAndNext(
765                    long membershipRequestId, long groupId, long userId, long statusId,
766                    OrderByComparator<MembershipRequest> orderByComparator)
767                    throws com.liferay.portal.exception.NoSuchMembershipRequestException {
768                    return getPersistence()
769                                       .findByG_U_S_PrevAndNext(membershipRequestId, groupId,
770                            userId, statusId, orderByComparator);
771            }
772    
773            /**
774            * Removes all the membership requests where groupId = &#63; and userId = &#63; and statusId = &#63; from the database.
775            *
776            * @param groupId the group ID
777            * @param userId the user ID
778            * @param statusId the status ID
779            */
780            public static void removeByG_U_S(long groupId, long userId, long statusId) {
781                    getPersistence().removeByG_U_S(groupId, userId, statusId);
782            }
783    
784            /**
785            * Returns the number of membership requests where groupId = &#63; and userId = &#63; and statusId = &#63;.
786            *
787            * @param groupId the group ID
788            * @param userId the user ID
789            * @param statusId the status ID
790            * @return the number of matching membership requests
791            */
792            public static int countByG_U_S(long groupId, long userId, long statusId) {
793                    return getPersistence().countByG_U_S(groupId, userId, statusId);
794            }
795    
796            /**
797            * Caches the membership request in the entity cache if it is enabled.
798            *
799            * @param membershipRequest the membership request
800            */
801            public static void cacheResult(MembershipRequest membershipRequest) {
802                    getPersistence().cacheResult(membershipRequest);
803            }
804    
805            /**
806            * Caches the membership requests in the entity cache if it is enabled.
807            *
808            * @param membershipRequests the membership requests
809            */
810            public static void cacheResult(List<MembershipRequest> membershipRequests) {
811                    getPersistence().cacheResult(membershipRequests);
812            }
813    
814            /**
815            * Creates a new membership request with the primary key. Does not add the membership request to the database.
816            *
817            * @param membershipRequestId the primary key for the new membership request
818            * @return the new membership request
819            */
820            public static MembershipRequest create(long membershipRequestId) {
821                    return getPersistence().create(membershipRequestId);
822            }
823    
824            /**
825            * Removes the membership request with the primary key from the database. Also notifies the appropriate model listeners.
826            *
827            * @param membershipRequestId the primary key of the membership request
828            * @return the membership request that was removed
829            * @throws NoSuchMembershipRequestException if a membership request with the primary key could not be found
830            */
831            public static MembershipRequest remove(long membershipRequestId)
832                    throws com.liferay.portal.exception.NoSuchMembershipRequestException {
833                    return getPersistence().remove(membershipRequestId);
834            }
835    
836            public static MembershipRequest updateImpl(
837                    MembershipRequest membershipRequest) {
838                    return getPersistence().updateImpl(membershipRequest);
839            }
840    
841            /**
842            * Returns the membership request with the primary key or throws a {@link NoSuchMembershipRequestException} if it could not be found.
843            *
844            * @param membershipRequestId the primary key of the membership request
845            * @return the membership request
846            * @throws NoSuchMembershipRequestException if a membership request with the primary key could not be found
847            */
848            public static MembershipRequest findByPrimaryKey(long membershipRequestId)
849                    throws com.liferay.portal.exception.NoSuchMembershipRequestException {
850                    return getPersistence().findByPrimaryKey(membershipRequestId);
851            }
852    
853            /**
854            * Returns the membership request with the primary key or returns <code>null</code> if it could not be found.
855            *
856            * @param membershipRequestId the primary key of the membership request
857            * @return the membership request, or <code>null</code> if a membership request with the primary key could not be found
858            */
859            public static MembershipRequest fetchByPrimaryKey(long membershipRequestId) {
860                    return getPersistence().fetchByPrimaryKey(membershipRequestId);
861            }
862    
863            public static java.util.Map<java.io.Serializable, MembershipRequest> fetchByPrimaryKeys(
864                    java.util.Set<java.io.Serializable> primaryKeys) {
865                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
866            }
867    
868            /**
869            * Returns all the membership requests.
870            *
871            * @return the membership requests
872            */
873            public static List<MembershipRequest> findAll() {
874                    return getPersistence().findAll();
875            }
876    
877            /**
878            * Returns a range of all the membership requests.
879            *
880            * <p>
881            * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link MembershipRequestModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
882            * </p>
883            *
884            * @param start the lower bound of the range of membership requests
885            * @param end the upper bound of the range of membership requests (not inclusive)
886            * @return the range of membership requests
887            */
888            public static List<MembershipRequest> findAll(int start, int end) {
889                    return getPersistence().findAll(start, end);
890            }
891    
892            /**
893            * Returns an ordered range of all the membership requests.
894            *
895            * <p>
896            * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link MembershipRequestModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
897            * </p>
898            *
899            * @param start the lower bound of the range of membership requests
900            * @param end the upper bound of the range of membership requests (not inclusive)
901            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
902            * @return the ordered range of membership requests
903            */
904            public static List<MembershipRequest> findAll(int start, int end,
905                    OrderByComparator<MembershipRequest> orderByComparator) {
906                    return getPersistence().findAll(start, end, orderByComparator);
907            }
908    
909            /**
910            * Returns an ordered range of all the membership requests.
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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link MembershipRequestModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
914            * </p>
915            *
916            * @param start the lower bound of the range of membership requests
917            * @param end the upper bound of the range of membership requests (not inclusive)
918            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
919            * @param retrieveFromCache whether to retrieve from the finder cache
920            * @return the ordered range of membership requests
921            */
922            public static List<MembershipRequest> findAll(int start, int end,
923                    OrderByComparator<MembershipRequest> orderByComparator,
924                    boolean retrieveFromCache) {
925                    return getPersistence()
926                                       .findAll(start, end, orderByComparator, retrieveFromCache);
927            }
928    
929            /**
930            * Removes all the membership requests from the database.
931            */
932            public static void removeAll() {
933                    getPersistence().removeAll();
934            }
935    
936            /**
937            * Returns the number of membership requests.
938            *
939            * @return the number of membership requests
940            */
941            public static int countAll() {
942                    return getPersistence().countAll();
943            }
944    
945            public static MembershipRequestPersistence getPersistence() {
946                    if (_persistence == null) {
947                            _persistence = (MembershipRequestPersistence)PortalBeanLocatorUtil.locate(MembershipRequestPersistence.class.getName());
948    
949                            ReferenceRegistry.registerReference(MembershipRequestUtil.class,
950                                    "_persistence");
951                    }
952    
953                    return _persistence;
954            }
955    
956            private static MembershipRequestPersistence _persistence;
957    }