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.portlet.social.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.service.ServiceContext;
024    
025    import com.liferay.portlet.social.model.SocialRequest;
026    
027    import java.util.List;
028    
029    /**
030     * The persistence utility for the social request service. This utility wraps {@link com.liferay.portlet.social.service.persistence.impl.SocialRequestPersistenceImpl} 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.
031     *
032     * <p>
033     * Caching information and settings can be found in <code>portal.properties</code>
034     * </p>
035     *
036     * @author Brian Wing Shun Chan
037     * @see SocialRequestPersistence
038     * @see com.liferay.portlet.social.service.persistence.impl.SocialRequestPersistenceImpl
039     * @generated
040     */
041    @ProviderType
042    public class SocialRequestUtil {
043            /*
044             * NOTE FOR DEVELOPERS:
045             *
046             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
047             */
048    
049            /**
050             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
051             */
052            public static void clearCache() {
053                    getPersistence().clearCache();
054            }
055    
056            /**
057             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
058             */
059            public static void clearCache(SocialRequest socialRequest) {
060                    getPersistence().clearCache(socialRequest);
061            }
062    
063            /**
064             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
065             */
066            public static long countWithDynamicQuery(DynamicQuery dynamicQuery) {
067                    return getPersistence().countWithDynamicQuery(dynamicQuery);
068            }
069    
070            /**
071             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
072             */
073            public static List<SocialRequest> findWithDynamicQuery(
074                    DynamicQuery dynamicQuery) {
075                    return getPersistence().findWithDynamicQuery(dynamicQuery);
076            }
077    
078            /**
079             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
080             */
081            public static List<SocialRequest> findWithDynamicQuery(
082                    DynamicQuery dynamicQuery, int start, int end) {
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<SocialRequest> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator<SocialRequest> orderByComparator) {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
099             */
100            public static SocialRequest update(SocialRequest socialRequest) {
101                    return getPersistence().update(socialRequest);
102            }
103    
104            /**
105             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
106             */
107            public static SocialRequest update(SocialRequest socialRequest,
108                    ServiceContext serviceContext) {
109                    return getPersistence().update(socialRequest, serviceContext);
110            }
111    
112            /**
113            * Returns all the social requests where uuid = &#63;.
114            *
115            * @param uuid the uuid
116            * @return the matching social requests
117            */
118            public static List<SocialRequest> findByUuid(java.lang.String uuid) {
119                    return getPersistence().findByUuid(uuid);
120            }
121    
122            /**
123            * Returns a range of all the social requests where uuid = &#63;.
124            *
125            * <p>
126            * 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 SocialRequestModelImpl}. 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.
127            * </p>
128            *
129            * @param uuid the uuid
130            * @param start the lower bound of the range of social requests
131            * @param end the upper bound of the range of social requests (not inclusive)
132            * @return the range of matching social requests
133            */
134            public static List<SocialRequest> findByUuid(java.lang.String uuid,
135                    int start, int end) {
136                    return getPersistence().findByUuid(uuid, start, end);
137            }
138    
139            /**
140            * Returns an ordered range of all the social requests where uuid = &#63;.
141            *
142            * <p>
143            * 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 SocialRequestModelImpl}. 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.
144            * </p>
145            *
146            * @param uuid the uuid
147            * @param start the lower bound of the range of social requests
148            * @param end the upper bound of the range of social requests (not inclusive)
149            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
150            * @return the ordered range of matching social requests
151            */
152            public static List<SocialRequest> findByUuid(java.lang.String uuid,
153                    int start, int end, OrderByComparator<SocialRequest> orderByComparator) {
154                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
155            }
156    
157            /**
158            * Returns an ordered range of all the social requests where uuid = &#63;.
159            *
160            * <p>
161            * 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 SocialRequestModelImpl}. 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.
162            * </p>
163            *
164            * @param uuid the uuid
165            * @param start the lower bound of the range of social requests
166            * @param end the upper bound of the range of social requests (not inclusive)
167            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
168            * @param retrieveFromCache whether to retrieve from the finder cache
169            * @return the ordered range of matching social requests
170            */
171            public static List<SocialRequest> findByUuid(java.lang.String uuid,
172                    int start, int end, OrderByComparator<SocialRequest> orderByComparator,
173                    boolean retrieveFromCache) {
174                    return getPersistence()
175                                       .findByUuid(uuid, start, end, orderByComparator,
176                            retrieveFromCache);
177            }
178    
179            /**
180            * Returns the first social request in the ordered set where uuid = &#63;.
181            *
182            * @param uuid the uuid
183            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
184            * @return the first matching social request
185            * @throws NoSuchRequestException if a matching social request could not be found
186            */
187            public static SocialRequest findByUuid_First(java.lang.String uuid,
188                    OrderByComparator<SocialRequest> orderByComparator)
189                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
190                    return getPersistence().findByUuid_First(uuid, orderByComparator);
191            }
192    
193            /**
194            * Returns the first social request in the ordered set where uuid = &#63;.
195            *
196            * @param uuid the uuid
197            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
198            * @return the first matching social request, or <code>null</code> if a matching social request could not be found
199            */
200            public static SocialRequest fetchByUuid_First(java.lang.String uuid,
201                    OrderByComparator<SocialRequest> orderByComparator) {
202                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
203            }
204    
205            /**
206            * Returns the last social request in the ordered set where uuid = &#63;.
207            *
208            * @param uuid the uuid
209            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
210            * @return the last matching social request
211            * @throws NoSuchRequestException if a matching social request could not be found
212            */
213            public static SocialRequest findByUuid_Last(java.lang.String uuid,
214                    OrderByComparator<SocialRequest> orderByComparator)
215                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
216                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
217            }
218    
219            /**
220            * Returns the last social request in the ordered set where uuid = &#63;.
221            *
222            * @param uuid the uuid
223            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
224            * @return the last matching social request, or <code>null</code> if a matching social request could not be found
225            */
226            public static SocialRequest fetchByUuid_Last(java.lang.String uuid,
227                    OrderByComparator<SocialRequest> orderByComparator) {
228                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
229            }
230    
231            /**
232            * Returns the social requests before and after the current social request in the ordered set where uuid = &#63;.
233            *
234            * @param requestId the primary key of the current social request
235            * @param uuid the uuid
236            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
237            * @return the previous, current, and next social request
238            * @throws NoSuchRequestException if a social request with the primary key could not be found
239            */
240            public static SocialRequest[] findByUuid_PrevAndNext(long requestId,
241                    java.lang.String uuid,
242                    OrderByComparator<SocialRequest> orderByComparator)
243                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
244                    return getPersistence()
245                                       .findByUuid_PrevAndNext(requestId, uuid, orderByComparator);
246            }
247    
248            /**
249            * Removes all the social requests where uuid = &#63; from the database.
250            *
251            * @param uuid the uuid
252            */
253            public static void removeByUuid(java.lang.String uuid) {
254                    getPersistence().removeByUuid(uuid);
255            }
256    
257            /**
258            * Returns the number of social requests where uuid = &#63;.
259            *
260            * @param uuid the uuid
261            * @return the number of matching social requests
262            */
263            public static int countByUuid(java.lang.String uuid) {
264                    return getPersistence().countByUuid(uuid);
265            }
266    
267            /**
268            * Returns the social request where uuid = &#63; and groupId = &#63; or throws a {@link NoSuchRequestException} if it could not be found.
269            *
270            * @param uuid the uuid
271            * @param groupId the group ID
272            * @return the matching social request
273            * @throws NoSuchRequestException if a matching social request could not be found
274            */
275            public static SocialRequest findByUUID_G(java.lang.String uuid, long groupId)
276                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
277                    return getPersistence().findByUUID_G(uuid, groupId);
278            }
279    
280            /**
281            * Returns the social request where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
282            *
283            * @param uuid the uuid
284            * @param groupId the group ID
285            * @return the matching social request, or <code>null</code> if a matching social request could not be found
286            */
287            public static SocialRequest fetchByUUID_G(java.lang.String uuid,
288                    long groupId) {
289                    return getPersistence().fetchByUUID_G(uuid, groupId);
290            }
291    
292            /**
293            * Returns the social request where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
294            *
295            * @param uuid the uuid
296            * @param groupId the group ID
297            * @param retrieveFromCache whether to retrieve from the finder cache
298            * @return the matching social request, or <code>null</code> if a matching social request could not be found
299            */
300            public static SocialRequest fetchByUUID_G(java.lang.String uuid,
301                    long groupId, boolean retrieveFromCache) {
302                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
303            }
304    
305            /**
306            * Removes the social request where uuid = &#63; and groupId = &#63; from the database.
307            *
308            * @param uuid the uuid
309            * @param groupId the group ID
310            * @return the social request that was removed
311            */
312            public static SocialRequest removeByUUID_G(java.lang.String uuid,
313                    long groupId)
314                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
315                    return getPersistence().removeByUUID_G(uuid, groupId);
316            }
317    
318            /**
319            * Returns the number of social requests where uuid = &#63; and groupId = &#63;.
320            *
321            * @param uuid the uuid
322            * @param groupId the group ID
323            * @return the number of matching social requests
324            */
325            public static int countByUUID_G(java.lang.String uuid, long groupId) {
326                    return getPersistence().countByUUID_G(uuid, groupId);
327            }
328    
329            /**
330            * Returns all the social requests where uuid = &#63; and companyId = &#63;.
331            *
332            * @param uuid the uuid
333            * @param companyId the company ID
334            * @return the matching social requests
335            */
336            public static List<SocialRequest> findByUuid_C(java.lang.String uuid,
337                    long companyId) {
338                    return getPersistence().findByUuid_C(uuid, companyId);
339            }
340    
341            /**
342            * Returns a range of all the social requests where uuid = &#63; and companyId = &#63;.
343            *
344            * <p>
345            * 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 SocialRequestModelImpl}. 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.
346            * </p>
347            *
348            * @param uuid the uuid
349            * @param companyId the company ID
350            * @param start the lower bound of the range of social requests
351            * @param end the upper bound of the range of social requests (not inclusive)
352            * @return the range of matching social requests
353            */
354            public static List<SocialRequest> findByUuid_C(java.lang.String uuid,
355                    long companyId, int start, int end) {
356                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
357            }
358    
359            /**
360            * Returns an ordered range of all the social requests where uuid = &#63; and companyId = &#63;.
361            *
362            * <p>
363            * 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 SocialRequestModelImpl}. 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.
364            * </p>
365            *
366            * @param uuid the uuid
367            * @param companyId the company ID
368            * @param start the lower bound of the range of social requests
369            * @param end the upper bound of the range of social requests (not inclusive)
370            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
371            * @return the ordered range of matching social requests
372            */
373            public static List<SocialRequest> findByUuid_C(java.lang.String uuid,
374                    long companyId, int start, int end,
375                    OrderByComparator<SocialRequest> orderByComparator) {
376                    return getPersistence()
377                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
378            }
379    
380            /**
381            * Returns an ordered range of all the social requests where uuid = &#63; and companyId = &#63;.
382            *
383            * <p>
384            * 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 SocialRequestModelImpl}. 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.
385            * </p>
386            *
387            * @param uuid the uuid
388            * @param companyId the company ID
389            * @param start the lower bound of the range of social requests
390            * @param end the upper bound of the range of social requests (not inclusive)
391            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
392            * @param retrieveFromCache whether to retrieve from the finder cache
393            * @return the ordered range of matching social requests
394            */
395            public static List<SocialRequest> findByUuid_C(java.lang.String uuid,
396                    long companyId, int start, int end,
397                    OrderByComparator<SocialRequest> orderByComparator,
398                    boolean retrieveFromCache) {
399                    return getPersistence()
400                                       .findByUuid_C(uuid, companyId, start, end,
401                            orderByComparator, retrieveFromCache);
402            }
403    
404            /**
405            * Returns the first social request in the ordered set where uuid = &#63; and companyId = &#63;.
406            *
407            * @param uuid the uuid
408            * @param companyId the company ID
409            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
410            * @return the first matching social request
411            * @throws NoSuchRequestException if a matching social request could not be found
412            */
413            public static SocialRequest findByUuid_C_First(java.lang.String uuid,
414                    long companyId, OrderByComparator<SocialRequest> orderByComparator)
415                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
416                    return getPersistence()
417                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
418            }
419    
420            /**
421            * Returns the first social request in the ordered set where uuid = &#63; and companyId = &#63;.
422            *
423            * @param uuid the uuid
424            * @param companyId the company ID
425            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
426            * @return the first matching social request, or <code>null</code> if a matching social request could not be found
427            */
428            public static SocialRequest fetchByUuid_C_First(java.lang.String uuid,
429                    long companyId, OrderByComparator<SocialRequest> orderByComparator) {
430                    return getPersistence()
431                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
432            }
433    
434            /**
435            * Returns the last social request in the ordered set where uuid = &#63; and companyId = &#63;.
436            *
437            * @param uuid the uuid
438            * @param companyId the company ID
439            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
440            * @return the last matching social request
441            * @throws NoSuchRequestException if a matching social request could not be found
442            */
443            public static SocialRequest findByUuid_C_Last(java.lang.String uuid,
444                    long companyId, OrderByComparator<SocialRequest> orderByComparator)
445                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
446                    return getPersistence()
447                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
448            }
449    
450            /**
451            * Returns the last social request in the ordered set where uuid = &#63; and companyId = &#63;.
452            *
453            * @param uuid the uuid
454            * @param companyId the company ID
455            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
456            * @return the last matching social request, or <code>null</code> if a matching social request could not be found
457            */
458            public static SocialRequest fetchByUuid_C_Last(java.lang.String uuid,
459                    long companyId, OrderByComparator<SocialRequest> orderByComparator) {
460                    return getPersistence()
461                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
462            }
463    
464            /**
465            * Returns the social requests before and after the current social request in the ordered set where uuid = &#63; and companyId = &#63;.
466            *
467            * @param requestId the primary key of the current social request
468            * @param uuid the uuid
469            * @param companyId the company ID
470            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
471            * @return the previous, current, and next social request
472            * @throws NoSuchRequestException if a social request with the primary key could not be found
473            */
474            public static SocialRequest[] findByUuid_C_PrevAndNext(long requestId,
475                    java.lang.String uuid, long companyId,
476                    OrderByComparator<SocialRequest> orderByComparator)
477                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
478                    return getPersistence()
479                                       .findByUuid_C_PrevAndNext(requestId, uuid, companyId,
480                            orderByComparator);
481            }
482    
483            /**
484            * Removes all the social requests where uuid = &#63; and companyId = &#63; from the database.
485            *
486            * @param uuid the uuid
487            * @param companyId the company ID
488            */
489            public static void removeByUuid_C(java.lang.String uuid, long companyId) {
490                    getPersistence().removeByUuid_C(uuid, companyId);
491            }
492    
493            /**
494            * Returns the number of social requests where uuid = &#63; and companyId = &#63;.
495            *
496            * @param uuid the uuid
497            * @param companyId the company ID
498            * @return the number of matching social requests
499            */
500            public static int countByUuid_C(java.lang.String uuid, long companyId) {
501                    return getPersistence().countByUuid_C(uuid, companyId);
502            }
503    
504            /**
505            * Returns all the social requests where companyId = &#63;.
506            *
507            * @param companyId the company ID
508            * @return the matching social requests
509            */
510            public static List<SocialRequest> findByCompanyId(long companyId) {
511                    return getPersistence().findByCompanyId(companyId);
512            }
513    
514            /**
515            * Returns a range of all the social requests where companyId = &#63;.
516            *
517            * <p>
518            * 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 SocialRequestModelImpl}. 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.
519            * </p>
520            *
521            * @param companyId the company ID
522            * @param start the lower bound of the range of social requests
523            * @param end the upper bound of the range of social requests (not inclusive)
524            * @return the range of matching social requests
525            */
526            public static List<SocialRequest> findByCompanyId(long companyId,
527                    int start, int end) {
528                    return getPersistence().findByCompanyId(companyId, start, end);
529            }
530    
531            /**
532            * Returns an ordered range of all the social requests where companyId = &#63;.
533            *
534            * <p>
535            * 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 SocialRequestModelImpl}. 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.
536            * </p>
537            *
538            * @param companyId the company ID
539            * @param start the lower bound of the range of social requests
540            * @param end the upper bound of the range of social requests (not inclusive)
541            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
542            * @return the ordered range of matching social requests
543            */
544            public static List<SocialRequest> findByCompanyId(long companyId,
545                    int start, int end, OrderByComparator<SocialRequest> orderByComparator) {
546                    return getPersistence()
547                                       .findByCompanyId(companyId, start, end, orderByComparator);
548            }
549    
550            /**
551            * Returns an ordered range of all the social requests where companyId = &#63;.
552            *
553            * <p>
554            * 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 SocialRequestModelImpl}. 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.
555            * </p>
556            *
557            * @param companyId the company ID
558            * @param start the lower bound of the range of social requests
559            * @param end the upper bound of the range of social requests (not inclusive)
560            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
561            * @param retrieveFromCache whether to retrieve from the finder cache
562            * @return the ordered range of matching social requests
563            */
564            public static List<SocialRequest> findByCompanyId(long companyId,
565                    int start, int end, OrderByComparator<SocialRequest> orderByComparator,
566                    boolean retrieveFromCache) {
567                    return getPersistence()
568                                       .findByCompanyId(companyId, start, end, orderByComparator,
569                            retrieveFromCache);
570            }
571    
572            /**
573            * Returns the first social request in the ordered set where companyId = &#63;.
574            *
575            * @param companyId the company ID
576            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
577            * @return the first matching social request
578            * @throws NoSuchRequestException if a matching social request could not be found
579            */
580            public static SocialRequest findByCompanyId_First(long companyId,
581                    OrderByComparator<SocialRequest> orderByComparator)
582                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
583                    return getPersistence()
584                                       .findByCompanyId_First(companyId, orderByComparator);
585            }
586    
587            /**
588            * Returns the first social request in the ordered set where companyId = &#63;.
589            *
590            * @param companyId the company ID
591            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
592            * @return the first matching social request, or <code>null</code> if a matching social request could not be found
593            */
594            public static SocialRequest fetchByCompanyId_First(long companyId,
595                    OrderByComparator<SocialRequest> orderByComparator) {
596                    return getPersistence()
597                                       .fetchByCompanyId_First(companyId, orderByComparator);
598            }
599    
600            /**
601            * Returns the last social request in the ordered set where companyId = &#63;.
602            *
603            * @param companyId the company ID
604            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
605            * @return the last matching social request
606            * @throws NoSuchRequestException if a matching social request could not be found
607            */
608            public static SocialRequest findByCompanyId_Last(long companyId,
609                    OrderByComparator<SocialRequest> orderByComparator)
610                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
611                    return getPersistence()
612                                       .findByCompanyId_Last(companyId, orderByComparator);
613            }
614    
615            /**
616            * Returns the last social request in the ordered set where companyId = &#63;.
617            *
618            * @param companyId the company ID
619            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
620            * @return the last matching social request, or <code>null</code> if a matching social request could not be found
621            */
622            public static SocialRequest fetchByCompanyId_Last(long companyId,
623                    OrderByComparator<SocialRequest> orderByComparator) {
624                    return getPersistence()
625                                       .fetchByCompanyId_Last(companyId, orderByComparator);
626            }
627    
628            /**
629            * Returns the social requests before and after the current social request in the ordered set where companyId = &#63;.
630            *
631            * @param requestId the primary key of the current social request
632            * @param companyId the company ID
633            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
634            * @return the previous, current, and next social request
635            * @throws NoSuchRequestException if a social request with the primary key could not be found
636            */
637            public static SocialRequest[] findByCompanyId_PrevAndNext(long requestId,
638                    long companyId, OrderByComparator<SocialRequest> orderByComparator)
639                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
640                    return getPersistence()
641                                       .findByCompanyId_PrevAndNext(requestId, companyId,
642                            orderByComparator);
643            }
644    
645            /**
646            * Removes all the social requests where companyId = &#63; from the database.
647            *
648            * @param companyId the company ID
649            */
650            public static void removeByCompanyId(long companyId) {
651                    getPersistence().removeByCompanyId(companyId);
652            }
653    
654            /**
655            * Returns the number of social requests where companyId = &#63;.
656            *
657            * @param companyId the company ID
658            * @return the number of matching social requests
659            */
660            public static int countByCompanyId(long companyId) {
661                    return getPersistence().countByCompanyId(companyId);
662            }
663    
664            /**
665            * Returns all the social requests where userId = &#63;.
666            *
667            * @param userId the user ID
668            * @return the matching social requests
669            */
670            public static List<SocialRequest> findByUserId(long userId) {
671                    return getPersistence().findByUserId(userId);
672            }
673    
674            /**
675            * Returns a range of all the social requests where userId = &#63;.
676            *
677            * <p>
678            * 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 SocialRequestModelImpl}. 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.
679            * </p>
680            *
681            * @param userId the user ID
682            * @param start the lower bound of the range of social requests
683            * @param end the upper bound of the range of social requests (not inclusive)
684            * @return the range of matching social requests
685            */
686            public static List<SocialRequest> findByUserId(long userId, int start,
687                    int end) {
688                    return getPersistence().findByUserId(userId, start, end);
689            }
690    
691            /**
692            * Returns an ordered range of all the social requests where userId = &#63;.
693            *
694            * <p>
695            * 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 SocialRequestModelImpl}. 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.
696            * </p>
697            *
698            * @param userId the user ID
699            * @param start the lower bound of the range of social requests
700            * @param end the upper bound of the range of social requests (not inclusive)
701            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
702            * @return the ordered range of matching social requests
703            */
704            public static List<SocialRequest> findByUserId(long userId, int start,
705                    int end, OrderByComparator<SocialRequest> orderByComparator) {
706                    return getPersistence()
707                                       .findByUserId(userId, start, end, orderByComparator);
708            }
709    
710            /**
711            * Returns an ordered range of all the social requests where userId = &#63;.
712            *
713            * <p>
714            * 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 SocialRequestModelImpl}. 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.
715            * </p>
716            *
717            * @param userId the user ID
718            * @param start the lower bound of the range of social requests
719            * @param end the upper bound of the range of social requests (not inclusive)
720            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
721            * @param retrieveFromCache whether to retrieve from the finder cache
722            * @return the ordered range of matching social requests
723            */
724            public static List<SocialRequest> findByUserId(long userId, int start,
725                    int end, OrderByComparator<SocialRequest> orderByComparator,
726                    boolean retrieveFromCache) {
727                    return getPersistence()
728                                       .findByUserId(userId, start, end, orderByComparator,
729                            retrieveFromCache);
730            }
731    
732            /**
733            * Returns the first social request in the ordered set where userId = &#63;.
734            *
735            * @param userId the user ID
736            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
737            * @return the first matching social request
738            * @throws NoSuchRequestException if a matching social request could not be found
739            */
740            public static SocialRequest findByUserId_First(long userId,
741                    OrderByComparator<SocialRequest> orderByComparator)
742                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
743                    return getPersistence().findByUserId_First(userId, orderByComparator);
744            }
745    
746            /**
747            * Returns the first social request in the ordered set where userId = &#63;.
748            *
749            * @param userId the user ID
750            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
751            * @return the first matching social request, or <code>null</code> if a matching social request could not be found
752            */
753            public static SocialRequest fetchByUserId_First(long userId,
754                    OrderByComparator<SocialRequest> orderByComparator) {
755                    return getPersistence().fetchByUserId_First(userId, orderByComparator);
756            }
757    
758            /**
759            * Returns the last social request in the ordered set where userId = &#63;.
760            *
761            * @param userId the user ID
762            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
763            * @return the last matching social request
764            * @throws NoSuchRequestException if a matching social request could not be found
765            */
766            public static SocialRequest findByUserId_Last(long userId,
767                    OrderByComparator<SocialRequest> orderByComparator)
768                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
769                    return getPersistence().findByUserId_Last(userId, orderByComparator);
770            }
771    
772            /**
773            * Returns the last social request in the ordered set where userId = &#63;.
774            *
775            * @param userId the user ID
776            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
777            * @return the last matching social request, or <code>null</code> if a matching social request could not be found
778            */
779            public static SocialRequest fetchByUserId_Last(long userId,
780                    OrderByComparator<SocialRequest> orderByComparator) {
781                    return getPersistence().fetchByUserId_Last(userId, orderByComparator);
782            }
783    
784            /**
785            * Returns the social requests before and after the current social request in the ordered set where userId = &#63;.
786            *
787            * @param requestId the primary key of the current social request
788            * @param userId the user ID
789            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
790            * @return the previous, current, and next social request
791            * @throws NoSuchRequestException if a social request with the primary key could not be found
792            */
793            public static SocialRequest[] findByUserId_PrevAndNext(long requestId,
794                    long userId, OrderByComparator<SocialRequest> orderByComparator)
795                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
796                    return getPersistence()
797                                       .findByUserId_PrevAndNext(requestId, userId,
798                            orderByComparator);
799            }
800    
801            /**
802            * Removes all the social requests where userId = &#63; from the database.
803            *
804            * @param userId the user ID
805            */
806            public static void removeByUserId(long userId) {
807                    getPersistence().removeByUserId(userId);
808            }
809    
810            /**
811            * Returns the number of social requests where userId = &#63;.
812            *
813            * @param userId the user ID
814            * @return the number of matching social requests
815            */
816            public static int countByUserId(long userId) {
817                    return getPersistence().countByUserId(userId);
818            }
819    
820            /**
821            * Returns all the social requests where receiverUserId = &#63;.
822            *
823            * @param receiverUserId the receiver user ID
824            * @return the matching social requests
825            */
826            public static List<SocialRequest> findByReceiverUserId(long receiverUserId) {
827                    return getPersistence().findByReceiverUserId(receiverUserId);
828            }
829    
830            /**
831            * Returns a range of all the social requests where receiverUserId = &#63;.
832            *
833            * <p>
834            * 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 SocialRequestModelImpl}. 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.
835            * </p>
836            *
837            * @param receiverUserId the receiver user ID
838            * @param start the lower bound of the range of social requests
839            * @param end the upper bound of the range of social requests (not inclusive)
840            * @return the range of matching social requests
841            */
842            public static List<SocialRequest> findByReceiverUserId(
843                    long receiverUserId, int start, int end) {
844                    return getPersistence().findByReceiverUserId(receiverUserId, start, end);
845            }
846    
847            /**
848            * Returns an ordered range of all the social requests where receiverUserId = &#63;.
849            *
850            * <p>
851            * 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 SocialRequestModelImpl}. 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.
852            * </p>
853            *
854            * @param receiverUserId the receiver user ID
855            * @param start the lower bound of the range of social requests
856            * @param end the upper bound of the range of social requests (not inclusive)
857            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
858            * @return the ordered range of matching social requests
859            */
860            public static List<SocialRequest> findByReceiverUserId(
861                    long receiverUserId, int start, int end,
862                    OrderByComparator<SocialRequest> orderByComparator) {
863                    return getPersistence()
864                                       .findByReceiverUserId(receiverUserId, start, end,
865                            orderByComparator);
866            }
867    
868            /**
869            * Returns an ordered range of all the social requests where receiverUserId = &#63;.
870            *
871            * <p>
872            * 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 SocialRequestModelImpl}. 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.
873            * </p>
874            *
875            * @param receiverUserId the receiver user ID
876            * @param start the lower bound of the range of social requests
877            * @param end the upper bound of the range of social requests (not inclusive)
878            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
879            * @param retrieveFromCache whether to retrieve from the finder cache
880            * @return the ordered range of matching social requests
881            */
882            public static List<SocialRequest> findByReceiverUserId(
883                    long receiverUserId, int start, int end,
884                    OrderByComparator<SocialRequest> orderByComparator,
885                    boolean retrieveFromCache) {
886                    return getPersistence()
887                                       .findByReceiverUserId(receiverUserId, start, end,
888                            orderByComparator, retrieveFromCache);
889            }
890    
891            /**
892            * Returns the first social request in the ordered set where receiverUserId = &#63;.
893            *
894            * @param receiverUserId the receiver user ID
895            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
896            * @return the first matching social request
897            * @throws NoSuchRequestException if a matching social request could not be found
898            */
899            public static SocialRequest findByReceiverUserId_First(
900                    long receiverUserId, OrderByComparator<SocialRequest> orderByComparator)
901                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
902                    return getPersistence()
903                                       .findByReceiverUserId_First(receiverUserId, orderByComparator);
904            }
905    
906            /**
907            * Returns the first social request in the ordered set where receiverUserId = &#63;.
908            *
909            * @param receiverUserId the receiver user ID
910            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
911            * @return the first matching social request, or <code>null</code> if a matching social request could not be found
912            */
913            public static SocialRequest fetchByReceiverUserId_First(
914                    long receiverUserId, OrderByComparator<SocialRequest> orderByComparator) {
915                    return getPersistence()
916                                       .fetchByReceiverUserId_First(receiverUserId,
917                            orderByComparator);
918            }
919    
920            /**
921            * Returns the last social request in the ordered set where receiverUserId = &#63;.
922            *
923            * @param receiverUserId the receiver user ID
924            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
925            * @return the last matching social request
926            * @throws NoSuchRequestException if a matching social request could not be found
927            */
928            public static SocialRequest findByReceiverUserId_Last(long receiverUserId,
929                    OrderByComparator<SocialRequest> orderByComparator)
930                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
931                    return getPersistence()
932                                       .findByReceiverUserId_Last(receiverUserId, orderByComparator);
933            }
934    
935            /**
936            * Returns the last social request in the ordered set where receiverUserId = &#63;.
937            *
938            * @param receiverUserId the receiver user ID
939            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
940            * @return the last matching social request, or <code>null</code> if a matching social request could not be found
941            */
942            public static SocialRequest fetchByReceiverUserId_Last(
943                    long receiverUserId, OrderByComparator<SocialRequest> orderByComparator) {
944                    return getPersistence()
945                                       .fetchByReceiverUserId_Last(receiverUserId, orderByComparator);
946            }
947    
948            /**
949            * Returns the social requests before and after the current social request in the ordered set where receiverUserId = &#63;.
950            *
951            * @param requestId the primary key of the current social request
952            * @param receiverUserId the receiver user ID
953            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
954            * @return the previous, current, and next social request
955            * @throws NoSuchRequestException if a social request with the primary key could not be found
956            */
957            public static SocialRequest[] findByReceiverUserId_PrevAndNext(
958                    long requestId, long receiverUserId,
959                    OrderByComparator<SocialRequest> orderByComparator)
960                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
961                    return getPersistence()
962                                       .findByReceiverUserId_PrevAndNext(requestId, receiverUserId,
963                            orderByComparator);
964            }
965    
966            /**
967            * Removes all the social requests where receiverUserId = &#63; from the database.
968            *
969            * @param receiverUserId the receiver user ID
970            */
971            public static void removeByReceiverUserId(long receiverUserId) {
972                    getPersistence().removeByReceiverUserId(receiverUserId);
973            }
974    
975            /**
976            * Returns the number of social requests where receiverUserId = &#63;.
977            *
978            * @param receiverUserId the receiver user ID
979            * @return the number of matching social requests
980            */
981            public static int countByReceiverUserId(long receiverUserId) {
982                    return getPersistence().countByReceiverUserId(receiverUserId);
983            }
984    
985            /**
986            * Returns all the social requests where userId = &#63; and status = &#63;.
987            *
988            * @param userId the user ID
989            * @param status the status
990            * @return the matching social requests
991            */
992            public static List<SocialRequest> findByU_S(long userId, int status) {
993                    return getPersistence().findByU_S(userId, status);
994            }
995    
996            /**
997            * Returns a range of all the social requests where userId = &#63; and status = &#63;.
998            *
999            * <p>
1000            * 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 SocialRequestModelImpl}. 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.
1001            * </p>
1002            *
1003            * @param userId the user ID
1004            * @param status the status
1005            * @param start the lower bound of the range of social requests
1006            * @param end the upper bound of the range of social requests (not inclusive)
1007            * @return the range of matching social requests
1008            */
1009            public static List<SocialRequest> findByU_S(long userId, int status,
1010                    int start, int end) {
1011                    return getPersistence().findByU_S(userId, status, start, end);
1012            }
1013    
1014            /**
1015            * Returns an ordered range of all the social requests where userId = &#63; and status = &#63;.
1016            *
1017            * <p>
1018            * 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 SocialRequestModelImpl}. 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.
1019            * </p>
1020            *
1021            * @param userId the user ID
1022            * @param status the status
1023            * @param start the lower bound of the range of social requests
1024            * @param end the upper bound of the range of social requests (not inclusive)
1025            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1026            * @return the ordered range of matching social requests
1027            */
1028            public static List<SocialRequest> findByU_S(long userId, int status,
1029                    int start, int end, OrderByComparator<SocialRequest> orderByComparator) {
1030                    return getPersistence()
1031                                       .findByU_S(userId, status, start, end, orderByComparator);
1032            }
1033    
1034            /**
1035            * Returns an ordered range of all the social requests where userId = &#63; and status = &#63;.
1036            *
1037            * <p>
1038            * 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 SocialRequestModelImpl}. 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.
1039            * </p>
1040            *
1041            * @param userId the user ID
1042            * @param status the status
1043            * @param start the lower bound of the range of social requests
1044            * @param end the upper bound of the range of social requests (not inclusive)
1045            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1046            * @param retrieveFromCache whether to retrieve from the finder cache
1047            * @return the ordered range of matching social requests
1048            */
1049            public static List<SocialRequest> findByU_S(long userId, int status,
1050                    int start, int end, OrderByComparator<SocialRequest> orderByComparator,
1051                    boolean retrieveFromCache) {
1052                    return getPersistence()
1053                                       .findByU_S(userId, status, start, end, orderByComparator,
1054                            retrieveFromCache);
1055            }
1056    
1057            /**
1058            * Returns the first social request in the ordered set where userId = &#63; and status = &#63;.
1059            *
1060            * @param userId the user ID
1061            * @param status the status
1062            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1063            * @return the first matching social request
1064            * @throws NoSuchRequestException if a matching social request could not be found
1065            */
1066            public static SocialRequest findByU_S_First(long userId, int status,
1067                    OrderByComparator<SocialRequest> orderByComparator)
1068                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
1069                    return getPersistence()
1070                                       .findByU_S_First(userId, status, orderByComparator);
1071            }
1072    
1073            /**
1074            * Returns the first social request in the ordered set where userId = &#63; and status = &#63;.
1075            *
1076            * @param userId the user ID
1077            * @param status the status
1078            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1079            * @return the first matching social request, or <code>null</code> if a matching social request could not be found
1080            */
1081            public static SocialRequest fetchByU_S_First(long userId, int status,
1082                    OrderByComparator<SocialRequest> orderByComparator) {
1083                    return getPersistence()
1084                                       .fetchByU_S_First(userId, status, orderByComparator);
1085            }
1086    
1087            /**
1088            * Returns the last social request in the ordered set where userId = &#63; and status = &#63;.
1089            *
1090            * @param userId the user ID
1091            * @param status the status
1092            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1093            * @return the last matching social request
1094            * @throws NoSuchRequestException if a matching social request could not be found
1095            */
1096            public static SocialRequest findByU_S_Last(long userId, int status,
1097                    OrderByComparator<SocialRequest> orderByComparator)
1098                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
1099                    return getPersistence().findByU_S_Last(userId, status, orderByComparator);
1100            }
1101    
1102            /**
1103            * Returns the last social request in the ordered set where userId = &#63; and status = &#63;.
1104            *
1105            * @param userId the user ID
1106            * @param status the status
1107            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1108            * @return the last matching social request, or <code>null</code> if a matching social request could not be found
1109            */
1110            public static SocialRequest fetchByU_S_Last(long userId, int status,
1111                    OrderByComparator<SocialRequest> orderByComparator) {
1112                    return getPersistence()
1113                                       .fetchByU_S_Last(userId, status, orderByComparator);
1114            }
1115    
1116            /**
1117            * Returns the social requests before and after the current social request in the ordered set where userId = &#63; and status = &#63;.
1118            *
1119            * @param requestId the primary key of the current social request
1120            * @param userId the user ID
1121            * @param status the status
1122            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1123            * @return the previous, current, and next social request
1124            * @throws NoSuchRequestException if a social request with the primary key could not be found
1125            */
1126            public static SocialRequest[] findByU_S_PrevAndNext(long requestId,
1127                    long userId, int status,
1128                    OrderByComparator<SocialRequest> orderByComparator)
1129                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
1130                    return getPersistence()
1131                                       .findByU_S_PrevAndNext(requestId, userId, status,
1132                            orderByComparator);
1133            }
1134    
1135            /**
1136            * Removes all the social requests where userId = &#63; and status = &#63; from the database.
1137            *
1138            * @param userId the user ID
1139            * @param status the status
1140            */
1141            public static void removeByU_S(long userId, int status) {
1142                    getPersistence().removeByU_S(userId, status);
1143            }
1144    
1145            /**
1146            * Returns the number of social requests where userId = &#63; and status = &#63;.
1147            *
1148            * @param userId the user ID
1149            * @param status the status
1150            * @return the number of matching social requests
1151            */
1152            public static int countByU_S(long userId, int status) {
1153                    return getPersistence().countByU_S(userId, status);
1154            }
1155    
1156            /**
1157            * Returns all the social requests where classNameId = &#63; and classPK = &#63;.
1158            *
1159            * @param classNameId the class name ID
1160            * @param classPK the class p k
1161            * @return the matching social requests
1162            */
1163            public static List<SocialRequest> findByC_C(long classNameId, long classPK) {
1164                    return getPersistence().findByC_C(classNameId, classPK);
1165            }
1166    
1167            /**
1168            * Returns a range of all the social requests where classNameId = &#63; and classPK = &#63;.
1169            *
1170            * <p>
1171            * 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 SocialRequestModelImpl}. 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.
1172            * </p>
1173            *
1174            * @param classNameId the class name ID
1175            * @param classPK the class p k
1176            * @param start the lower bound of the range of social requests
1177            * @param end the upper bound of the range of social requests (not inclusive)
1178            * @return the range of matching social requests
1179            */
1180            public static List<SocialRequest> findByC_C(long classNameId, long classPK,
1181                    int start, int end) {
1182                    return getPersistence().findByC_C(classNameId, classPK, start, end);
1183            }
1184    
1185            /**
1186            * Returns an ordered range of all the social requests where classNameId = &#63; and classPK = &#63;.
1187            *
1188            * <p>
1189            * 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 SocialRequestModelImpl}. 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.
1190            * </p>
1191            *
1192            * @param classNameId the class name ID
1193            * @param classPK the class p k
1194            * @param start the lower bound of the range of social requests
1195            * @param end the upper bound of the range of social requests (not inclusive)
1196            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1197            * @return the ordered range of matching social requests
1198            */
1199            public static List<SocialRequest> findByC_C(long classNameId, long classPK,
1200                    int start, int end, OrderByComparator<SocialRequest> orderByComparator) {
1201                    return getPersistence()
1202                                       .findByC_C(classNameId, classPK, start, end,
1203                            orderByComparator);
1204            }
1205    
1206            /**
1207            * Returns an ordered range of all the social requests where classNameId = &#63; and classPK = &#63;.
1208            *
1209            * <p>
1210            * 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 SocialRequestModelImpl}. 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.
1211            * </p>
1212            *
1213            * @param classNameId the class name ID
1214            * @param classPK the class p k
1215            * @param start the lower bound of the range of social requests
1216            * @param end the upper bound of the range of social requests (not inclusive)
1217            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1218            * @param retrieveFromCache whether to retrieve from the finder cache
1219            * @return the ordered range of matching social requests
1220            */
1221            public static List<SocialRequest> findByC_C(long classNameId, long classPK,
1222                    int start, int end, OrderByComparator<SocialRequest> orderByComparator,
1223                    boolean retrieveFromCache) {
1224                    return getPersistence()
1225                                       .findByC_C(classNameId, classPK, start, end,
1226                            orderByComparator, retrieveFromCache);
1227            }
1228    
1229            /**
1230            * Returns the first social request in the ordered set where classNameId = &#63; and classPK = &#63;.
1231            *
1232            * @param classNameId the class name ID
1233            * @param classPK the class p k
1234            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1235            * @return the first matching social request
1236            * @throws NoSuchRequestException if a matching social request could not be found
1237            */
1238            public static SocialRequest findByC_C_First(long classNameId, long classPK,
1239                    OrderByComparator<SocialRequest> orderByComparator)
1240                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
1241                    return getPersistence()
1242                                       .findByC_C_First(classNameId, classPK, orderByComparator);
1243            }
1244    
1245            /**
1246            * Returns the first social request in the ordered set where classNameId = &#63; and classPK = &#63;.
1247            *
1248            * @param classNameId the class name ID
1249            * @param classPK the class p k
1250            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1251            * @return the first matching social request, or <code>null</code> if a matching social request could not be found
1252            */
1253            public static SocialRequest fetchByC_C_First(long classNameId,
1254                    long classPK, OrderByComparator<SocialRequest> orderByComparator) {
1255                    return getPersistence()
1256                                       .fetchByC_C_First(classNameId, classPK, orderByComparator);
1257            }
1258    
1259            /**
1260            * Returns the last social request in the ordered set where classNameId = &#63; and classPK = &#63;.
1261            *
1262            * @param classNameId the class name ID
1263            * @param classPK the class p k
1264            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1265            * @return the last matching social request
1266            * @throws NoSuchRequestException if a matching social request could not be found
1267            */
1268            public static SocialRequest findByC_C_Last(long classNameId, long classPK,
1269                    OrderByComparator<SocialRequest> orderByComparator)
1270                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
1271                    return getPersistence()
1272                                       .findByC_C_Last(classNameId, classPK, orderByComparator);
1273            }
1274    
1275            /**
1276            * Returns the last social request in the ordered set where classNameId = &#63; and classPK = &#63;.
1277            *
1278            * @param classNameId the class name ID
1279            * @param classPK the class p k
1280            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1281            * @return the last matching social request, or <code>null</code> if a matching social request could not be found
1282            */
1283            public static SocialRequest fetchByC_C_Last(long classNameId, long classPK,
1284                    OrderByComparator<SocialRequest> orderByComparator) {
1285                    return getPersistence()
1286                                       .fetchByC_C_Last(classNameId, classPK, orderByComparator);
1287            }
1288    
1289            /**
1290            * Returns the social requests before and after the current social request in the ordered set where classNameId = &#63; and classPK = &#63;.
1291            *
1292            * @param requestId the primary key of the current social request
1293            * @param classNameId the class name ID
1294            * @param classPK the class p k
1295            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1296            * @return the previous, current, and next social request
1297            * @throws NoSuchRequestException if a social request with the primary key could not be found
1298            */
1299            public static SocialRequest[] findByC_C_PrevAndNext(long requestId,
1300                    long classNameId, long classPK,
1301                    OrderByComparator<SocialRequest> orderByComparator)
1302                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
1303                    return getPersistence()
1304                                       .findByC_C_PrevAndNext(requestId, classNameId, classPK,
1305                            orderByComparator);
1306            }
1307    
1308            /**
1309            * Removes all the social requests where classNameId = &#63; and classPK = &#63; from the database.
1310            *
1311            * @param classNameId the class name ID
1312            * @param classPK the class p k
1313            */
1314            public static void removeByC_C(long classNameId, long classPK) {
1315                    getPersistence().removeByC_C(classNameId, classPK);
1316            }
1317    
1318            /**
1319            * Returns the number of social requests where classNameId = &#63; and classPK = &#63;.
1320            *
1321            * @param classNameId the class name ID
1322            * @param classPK the class p k
1323            * @return the number of matching social requests
1324            */
1325            public static int countByC_C(long classNameId, long classPK) {
1326                    return getPersistence().countByC_C(classNameId, classPK);
1327            }
1328    
1329            /**
1330            * Returns all the social requests where receiverUserId = &#63; and status = &#63;.
1331            *
1332            * @param receiverUserId the receiver user ID
1333            * @param status the status
1334            * @return the matching social requests
1335            */
1336            public static List<SocialRequest> findByR_S(long receiverUserId, int status) {
1337                    return getPersistence().findByR_S(receiverUserId, status);
1338            }
1339    
1340            /**
1341            * Returns a range of all the social requests where receiverUserId = &#63; and status = &#63;.
1342            *
1343            * <p>
1344            * 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 SocialRequestModelImpl}. 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.
1345            * </p>
1346            *
1347            * @param receiverUserId the receiver user ID
1348            * @param status the status
1349            * @param start the lower bound of the range of social requests
1350            * @param end the upper bound of the range of social requests (not inclusive)
1351            * @return the range of matching social requests
1352            */
1353            public static List<SocialRequest> findByR_S(long receiverUserId,
1354                    int status, int start, int end) {
1355                    return getPersistence().findByR_S(receiverUserId, status, start, end);
1356            }
1357    
1358            /**
1359            * Returns an ordered range of all the social requests where receiverUserId = &#63; and status = &#63;.
1360            *
1361            * <p>
1362            * 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 SocialRequestModelImpl}. 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.
1363            * </p>
1364            *
1365            * @param receiverUserId the receiver user ID
1366            * @param status the status
1367            * @param start the lower bound of the range of social requests
1368            * @param end the upper bound of the range of social requests (not inclusive)
1369            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1370            * @return the ordered range of matching social requests
1371            */
1372            public static List<SocialRequest> findByR_S(long receiverUserId,
1373                    int status, int start, int end,
1374                    OrderByComparator<SocialRequest> orderByComparator) {
1375                    return getPersistence()
1376                                       .findByR_S(receiverUserId, status, start, end,
1377                            orderByComparator);
1378            }
1379    
1380            /**
1381            * Returns an ordered range of all the social requests where receiverUserId = &#63; and status = &#63;.
1382            *
1383            * <p>
1384            * 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 SocialRequestModelImpl}. 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.
1385            * </p>
1386            *
1387            * @param receiverUserId the receiver user ID
1388            * @param status the status
1389            * @param start the lower bound of the range of social requests
1390            * @param end the upper bound of the range of social requests (not inclusive)
1391            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1392            * @param retrieveFromCache whether to retrieve from the finder cache
1393            * @return the ordered range of matching social requests
1394            */
1395            public static List<SocialRequest> findByR_S(long receiverUserId,
1396                    int status, int start, int end,
1397                    OrderByComparator<SocialRequest> orderByComparator,
1398                    boolean retrieveFromCache) {
1399                    return getPersistence()
1400                                       .findByR_S(receiverUserId, status, start, end,
1401                            orderByComparator, retrieveFromCache);
1402            }
1403    
1404            /**
1405            * Returns the first social request in the ordered set where receiverUserId = &#63; and status = &#63;.
1406            *
1407            * @param receiverUserId the receiver user ID
1408            * @param status the status
1409            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1410            * @return the first matching social request
1411            * @throws NoSuchRequestException if a matching social request could not be found
1412            */
1413            public static SocialRequest findByR_S_First(long receiverUserId,
1414                    int status, OrderByComparator<SocialRequest> orderByComparator)
1415                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
1416                    return getPersistence()
1417                                       .findByR_S_First(receiverUserId, status, orderByComparator);
1418            }
1419    
1420            /**
1421            * Returns the first social request in the ordered set where receiverUserId = &#63; and status = &#63;.
1422            *
1423            * @param receiverUserId the receiver user ID
1424            * @param status the status
1425            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1426            * @return the first matching social request, or <code>null</code> if a matching social request could not be found
1427            */
1428            public static SocialRequest fetchByR_S_First(long receiverUserId,
1429                    int status, OrderByComparator<SocialRequest> orderByComparator) {
1430                    return getPersistence()
1431                                       .fetchByR_S_First(receiverUserId, status, orderByComparator);
1432            }
1433    
1434            /**
1435            * Returns the last social request in the ordered set where receiverUserId = &#63; and status = &#63;.
1436            *
1437            * @param receiverUserId the receiver user ID
1438            * @param status the status
1439            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1440            * @return the last matching social request
1441            * @throws NoSuchRequestException if a matching social request could not be found
1442            */
1443            public static SocialRequest findByR_S_Last(long receiverUserId, int status,
1444                    OrderByComparator<SocialRequest> orderByComparator)
1445                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
1446                    return getPersistence()
1447                                       .findByR_S_Last(receiverUserId, status, orderByComparator);
1448            }
1449    
1450            /**
1451            * Returns the last social request in the ordered set where receiverUserId = &#63; and status = &#63;.
1452            *
1453            * @param receiverUserId the receiver user ID
1454            * @param status the status
1455            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1456            * @return the last matching social request, or <code>null</code> if a matching social request could not be found
1457            */
1458            public static SocialRequest fetchByR_S_Last(long receiverUserId,
1459                    int status, OrderByComparator<SocialRequest> orderByComparator) {
1460                    return getPersistence()
1461                                       .fetchByR_S_Last(receiverUserId, status, orderByComparator);
1462            }
1463    
1464            /**
1465            * Returns the social requests before and after the current social request in the ordered set where receiverUserId = &#63; and status = &#63;.
1466            *
1467            * @param requestId the primary key of the current social request
1468            * @param receiverUserId the receiver user ID
1469            * @param status the status
1470            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1471            * @return the previous, current, and next social request
1472            * @throws NoSuchRequestException if a social request with the primary key could not be found
1473            */
1474            public static SocialRequest[] findByR_S_PrevAndNext(long requestId,
1475                    long receiverUserId, int status,
1476                    OrderByComparator<SocialRequest> orderByComparator)
1477                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
1478                    return getPersistence()
1479                                       .findByR_S_PrevAndNext(requestId, receiverUserId, status,
1480                            orderByComparator);
1481            }
1482    
1483            /**
1484            * Removes all the social requests where receiverUserId = &#63; and status = &#63; from the database.
1485            *
1486            * @param receiverUserId the receiver user ID
1487            * @param status the status
1488            */
1489            public static void removeByR_S(long receiverUserId, int status) {
1490                    getPersistence().removeByR_S(receiverUserId, status);
1491            }
1492    
1493            /**
1494            * Returns the number of social requests where receiverUserId = &#63; and status = &#63;.
1495            *
1496            * @param receiverUserId the receiver user ID
1497            * @param status the status
1498            * @return the number of matching social requests
1499            */
1500            public static int countByR_S(long receiverUserId, int status) {
1501                    return getPersistence().countByR_S(receiverUserId, status);
1502            }
1503    
1504            /**
1505            * Returns the social request where userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; and receiverUserId = &#63; or throws a {@link NoSuchRequestException} if it could not be found.
1506            *
1507            * @param userId the user ID
1508            * @param classNameId the class name ID
1509            * @param classPK the class p k
1510            * @param type the type
1511            * @param receiverUserId the receiver user ID
1512            * @return the matching social request
1513            * @throws NoSuchRequestException if a matching social request could not be found
1514            */
1515            public static SocialRequest findByU_C_C_T_R(long userId, long classNameId,
1516                    long classPK, int type, long receiverUserId)
1517                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
1518                    return getPersistence()
1519                                       .findByU_C_C_T_R(userId, classNameId, classPK, type,
1520                            receiverUserId);
1521            }
1522    
1523            /**
1524            * Returns the social request where userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; and receiverUserId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1525            *
1526            * @param userId the user ID
1527            * @param classNameId the class name ID
1528            * @param classPK the class p k
1529            * @param type the type
1530            * @param receiverUserId the receiver user ID
1531            * @return the matching social request, or <code>null</code> if a matching social request could not be found
1532            */
1533            public static SocialRequest fetchByU_C_C_T_R(long userId, long classNameId,
1534                    long classPK, int type, long receiverUserId) {
1535                    return getPersistence()
1536                                       .fetchByU_C_C_T_R(userId, classNameId, classPK, type,
1537                            receiverUserId);
1538            }
1539    
1540            /**
1541            * Returns the social request where userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; and receiverUserId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1542            *
1543            * @param userId the user ID
1544            * @param classNameId the class name ID
1545            * @param classPK the class p k
1546            * @param type the type
1547            * @param receiverUserId the receiver user ID
1548            * @param retrieveFromCache whether to retrieve from the finder cache
1549            * @return the matching social request, or <code>null</code> if a matching social request could not be found
1550            */
1551            public static SocialRequest fetchByU_C_C_T_R(long userId, long classNameId,
1552                    long classPK, int type, long receiverUserId, boolean retrieveFromCache) {
1553                    return getPersistence()
1554                                       .fetchByU_C_C_T_R(userId, classNameId, classPK, type,
1555                            receiverUserId, retrieveFromCache);
1556            }
1557    
1558            /**
1559            * Removes the social request where userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; and receiverUserId = &#63; from the database.
1560            *
1561            * @param userId the user ID
1562            * @param classNameId the class name ID
1563            * @param classPK the class p k
1564            * @param type the type
1565            * @param receiverUserId the receiver user ID
1566            * @return the social request that was removed
1567            */
1568            public static SocialRequest removeByU_C_C_T_R(long userId,
1569                    long classNameId, long classPK, int type, long receiverUserId)
1570                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
1571                    return getPersistence()
1572                                       .removeByU_C_C_T_R(userId, classNameId, classPK, type,
1573                            receiverUserId);
1574            }
1575    
1576            /**
1577            * Returns the number of social requests where userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; and receiverUserId = &#63;.
1578            *
1579            * @param userId the user ID
1580            * @param classNameId the class name ID
1581            * @param classPK the class p k
1582            * @param type the type
1583            * @param receiverUserId the receiver user ID
1584            * @return the number of matching social requests
1585            */
1586            public static int countByU_C_C_T_R(long userId, long classNameId,
1587                    long classPK, int type, long receiverUserId) {
1588                    return getPersistence()
1589                                       .countByU_C_C_T_R(userId, classNameId, classPK, type,
1590                            receiverUserId);
1591            }
1592    
1593            /**
1594            * Returns all the social requests where userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; and status = &#63;.
1595            *
1596            * @param userId the user ID
1597            * @param classNameId the class name ID
1598            * @param classPK the class p k
1599            * @param type the type
1600            * @param status the status
1601            * @return the matching social requests
1602            */
1603            public static List<SocialRequest> findByU_C_C_T_S(long userId,
1604                    long classNameId, long classPK, int type, int status) {
1605                    return getPersistence()
1606                                       .findByU_C_C_T_S(userId, classNameId, classPK, type, status);
1607            }
1608    
1609            /**
1610            * Returns a range of all the social requests where userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; and status = &#63;.
1611            *
1612            * <p>
1613            * 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 SocialRequestModelImpl}. 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.
1614            * </p>
1615            *
1616            * @param userId the user ID
1617            * @param classNameId the class name ID
1618            * @param classPK the class p k
1619            * @param type the type
1620            * @param status the status
1621            * @param start the lower bound of the range of social requests
1622            * @param end the upper bound of the range of social requests (not inclusive)
1623            * @return the range of matching social requests
1624            */
1625            public static List<SocialRequest> findByU_C_C_T_S(long userId,
1626                    long classNameId, long classPK, int type, int status, int start, int end) {
1627                    return getPersistence()
1628                                       .findByU_C_C_T_S(userId, classNameId, classPK, type, status,
1629                            start, end);
1630            }
1631    
1632            /**
1633            * Returns an ordered range of all the social requests where userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; and status = &#63;.
1634            *
1635            * <p>
1636            * 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 SocialRequestModelImpl}. 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.
1637            * </p>
1638            *
1639            * @param userId the user ID
1640            * @param classNameId the class name ID
1641            * @param classPK the class p k
1642            * @param type the type
1643            * @param status the status
1644            * @param start the lower bound of the range of social requests
1645            * @param end the upper bound of the range of social requests (not inclusive)
1646            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1647            * @return the ordered range of matching social requests
1648            */
1649            public static List<SocialRequest> findByU_C_C_T_S(long userId,
1650                    long classNameId, long classPK, int type, int status, int start,
1651                    int end, OrderByComparator<SocialRequest> orderByComparator) {
1652                    return getPersistence()
1653                                       .findByU_C_C_T_S(userId, classNameId, classPK, type, status,
1654                            start, end, orderByComparator);
1655            }
1656    
1657            /**
1658            * Returns an ordered range of all the social requests where userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; and status = &#63;.
1659            *
1660            * <p>
1661            * 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 SocialRequestModelImpl}. 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.
1662            * </p>
1663            *
1664            * @param userId the user ID
1665            * @param classNameId the class name ID
1666            * @param classPK the class p k
1667            * @param type the type
1668            * @param status the status
1669            * @param start the lower bound of the range of social requests
1670            * @param end the upper bound of the range of social requests (not inclusive)
1671            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1672            * @param retrieveFromCache whether to retrieve from the finder cache
1673            * @return the ordered range of matching social requests
1674            */
1675            public static List<SocialRequest> findByU_C_C_T_S(long userId,
1676                    long classNameId, long classPK, int type, int status, int start,
1677                    int end, OrderByComparator<SocialRequest> orderByComparator,
1678                    boolean retrieveFromCache) {
1679                    return getPersistence()
1680                                       .findByU_C_C_T_S(userId, classNameId, classPK, type, status,
1681                            start, end, orderByComparator, retrieveFromCache);
1682            }
1683    
1684            /**
1685            * Returns the first social request in the ordered set where userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; and status = &#63;.
1686            *
1687            * @param userId the user ID
1688            * @param classNameId the class name ID
1689            * @param classPK the class p k
1690            * @param type the type
1691            * @param status the status
1692            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1693            * @return the first matching social request
1694            * @throws NoSuchRequestException if a matching social request could not be found
1695            */
1696            public static SocialRequest findByU_C_C_T_S_First(long userId,
1697                    long classNameId, long classPK, int type, int status,
1698                    OrderByComparator<SocialRequest> orderByComparator)
1699                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
1700                    return getPersistence()
1701                                       .findByU_C_C_T_S_First(userId, classNameId, classPK, type,
1702                            status, orderByComparator);
1703            }
1704    
1705            /**
1706            * Returns the first social request in the ordered set where userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; and status = &#63;.
1707            *
1708            * @param userId the user ID
1709            * @param classNameId the class name ID
1710            * @param classPK the class p k
1711            * @param type the type
1712            * @param status the status
1713            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1714            * @return the first matching social request, or <code>null</code> if a matching social request could not be found
1715            */
1716            public static SocialRequest fetchByU_C_C_T_S_First(long userId,
1717                    long classNameId, long classPK, int type, int status,
1718                    OrderByComparator<SocialRequest> orderByComparator) {
1719                    return getPersistence()
1720                                       .fetchByU_C_C_T_S_First(userId, classNameId, classPK, type,
1721                            status, orderByComparator);
1722            }
1723    
1724            /**
1725            * Returns the last social request in the ordered set where userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; and status = &#63;.
1726            *
1727            * @param userId the user ID
1728            * @param classNameId the class name ID
1729            * @param classPK the class p k
1730            * @param type the type
1731            * @param status the status
1732            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1733            * @return the last matching social request
1734            * @throws NoSuchRequestException if a matching social request could not be found
1735            */
1736            public static SocialRequest findByU_C_C_T_S_Last(long userId,
1737                    long classNameId, long classPK, int type, int status,
1738                    OrderByComparator<SocialRequest> orderByComparator)
1739                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
1740                    return getPersistence()
1741                                       .findByU_C_C_T_S_Last(userId, classNameId, classPK, type,
1742                            status, orderByComparator);
1743            }
1744    
1745            /**
1746            * Returns the last social request in the ordered set where userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; and status = &#63;.
1747            *
1748            * @param userId the user ID
1749            * @param classNameId the class name ID
1750            * @param classPK the class p k
1751            * @param type the type
1752            * @param status the status
1753            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1754            * @return the last matching social request, or <code>null</code> if a matching social request could not be found
1755            */
1756            public static SocialRequest fetchByU_C_C_T_S_Last(long userId,
1757                    long classNameId, long classPK, int type, int status,
1758                    OrderByComparator<SocialRequest> orderByComparator) {
1759                    return getPersistence()
1760                                       .fetchByU_C_C_T_S_Last(userId, classNameId, classPK, type,
1761                            status, orderByComparator);
1762            }
1763    
1764            /**
1765            * Returns the social requests before and after the current social request in the ordered set where userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; and status = &#63;.
1766            *
1767            * @param requestId the primary key of the current social request
1768            * @param userId the user ID
1769            * @param classNameId the class name ID
1770            * @param classPK the class p k
1771            * @param type the type
1772            * @param status the status
1773            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1774            * @return the previous, current, and next social request
1775            * @throws NoSuchRequestException if a social request with the primary key could not be found
1776            */
1777            public static SocialRequest[] findByU_C_C_T_S_PrevAndNext(long requestId,
1778                    long userId, long classNameId, long classPK, int type, int status,
1779                    OrderByComparator<SocialRequest> orderByComparator)
1780                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
1781                    return getPersistence()
1782                                       .findByU_C_C_T_S_PrevAndNext(requestId, userId, classNameId,
1783                            classPK, type, status, orderByComparator);
1784            }
1785    
1786            /**
1787            * Removes all the social requests where userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; and status = &#63; from the database.
1788            *
1789            * @param userId the user ID
1790            * @param classNameId the class name ID
1791            * @param classPK the class p k
1792            * @param type the type
1793            * @param status the status
1794            */
1795            public static void removeByU_C_C_T_S(long userId, long classNameId,
1796                    long classPK, int type, int status) {
1797                    getPersistence()
1798                            .removeByU_C_C_T_S(userId, classNameId, classPK, type, status);
1799            }
1800    
1801            /**
1802            * Returns the number of social requests where userId = &#63; and classNameId = &#63; and classPK = &#63; and type = &#63; and status = &#63;.
1803            *
1804            * @param userId the user ID
1805            * @param classNameId the class name ID
1806            * @param classPK the class p k
1807            * @param type the type
1808            * @param status the status
1809            * @return the number of matching social requests
1810            */
1811            public static int countByU_C_C_T_S(long userId, long classNameId,
1812                    long classPK, int type, int status) {
1813                    return getPersistence()
1814                                       .countByU_C_C_T_S(userId, classNameId, classPK, type, status);
1815            }
1816    
1817            /**
1818            * Returns all the social requests where classNameId = &#63; and classPK = &#63; and type = &#63; and receiverUserId = &#63; and status = &#63;.
1819            *
1820            * @param classNameId the class name ID
1821            * @param classPK the class p k
1822            * @param type the type
1823            * @param receiverUserId the receiver user ID
1824            * @param status the status
1825            * @return the matching social requests
1826            */
1827            public static List<SocialRequest> findByC_C_T_R_S(long classNameId,
1828                    long classPK, int type, long receiverUserId, int status) {
1829                    return getPersistence()
1830                                       .findByC_C_T_R_S(classNameId, classPK, type, receiverUserId,
1831                            status);
1832            }
1833    
1834            /**
1835            * Returns a range of all the social requests where classNameId = &#63; and classPK = &#63; and type = &#63; and receiverUserId = &#63; and status = &#63;.
1836            *
1837            * <p>
1838            * 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 SocialRequestModelImpl}. 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.
1839            * </p>
1840            *
1841            * @param classNameId the class name ID
1842            * @param classPK the class p k
1843            * @param type the type
1844            * @param receiverUserId the receiver user ID
1845            * @param status the status
1846            * @param start the lower bound of the range of social requests
1847            * @param end the upper bound of the range of social requests (not inclusive)
1848            * @return the range of matching social requests
1849            */
1850            public static List<SocialRequest> findByC_C_T_R_S(long classNameId,
1851                    long classPK, int type, long receiverUserId, int status, int start,
1852                    int end) {
1853                    return getPersistence()
1854                                       .findByC_C_T_R_S(classNameId, classPK, type, receiverUserId,
1855                            status, start, end);
1856            }
1857    
1858            /**
1859            * Returns an ordered range of all the social requests where classNameId = &#63; and classPK = &#63; and type = &#63; and receiverUserId = &#63; and status = &#63;.
1860            *
1861            * <p>
1862            * 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 SocialRequestModelImpl}. 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.
1863            * </p>
1864            *
1865            * @param classNameId the class name ID
1866            * @param classPK the class p k
1867            * @param type the type
1868            * @param receiverUserId the receiver user ID
1869            * @param status the status
1870            * @param start the lower bound of the range of social requests
1871            * @param end the upper bound of the range of social requests (not inclusive)
1872            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1873            * @return the ordered range of matching social requests
1874            */
1875            public static List<SocialRequest> findByC_C_T_R_S(long classNameId,
1876                    long classPK, int type, long receiverUserId, int status, int start,
1877                    int end, OrderByComparator<SocialRequest> orderByComparator) {
1878                    return getPersistence()
1879                                       .findByC_C_T_R_S(classNameId, classPK, type, receiverUserId,
1880                            status, start, end, orderByComparator);
1881            }
1882    
1883            /**
1884            * Returns an ordered range of all the social requests where classNameId = &#63; and classPK = &#63; and type = &#63; and receiverUserId = &#63; and status = &#63;.
1885            *
1886            * <p>
1887            * 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 SocialRequestModelImpl}. 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.
1888            * </p>
1889            *
1890            * @param classNameId the class name ID
1891            * @param classPK the class p k
1892            * @param type the type
1893            * @param receiverUserId the receiver user ID
1894            * @param status the status
1895            * @param start the lower bound of the range of social requests
1896            * @param end the upper bound of the range of social requests (not inclusive)
1897            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1898            * @param retrieveFromCache whether to retrieve from the finder cache
1899            * @return the ordered range of matching social requests
1900            */
1901            public static List<SocialRequest> findByC_C_T_R_S(long classNameId,
1902                    long classPK, int type, long receiverUserId, int status, int start,
1903                    int end, OrderByComparator<SocialRequest> orderByComparator,
1904                    boolean retrieveFromCache) {
1905                    return getPersistence()
1906                                       .findByC_C_T_R_S(classNameId, classPK, type, receiverUserId,
1907                            status, start, end, orderByComparator, retrieveFromCache);
1908            }
1909    
1910            /**
1911            * Returns the first social request in the ordered set where classNameId = &#63; and classPK = &#63; and type = &#63; and receiverUserId = &#63; and status = &#63;.
1912            *
1913            * @param classNameId the class name ID
1914            * @param classPK the class p k
1915            * @param type the type
1916            * @param receiverUserId the receiver user ID
1917            * @param status the status
1918            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1919            * @return the first matching social request
1920            * @throws NoSuchRequestException if a matching social request could not be found
1921            */
1922            public static SocialRequest findByC_C_T_R_S_First(long classNameId,
1923                    long classPK, int type, long receiverUserId, int status,
1924                    OrderByComparator<SocialRequest> orderByComparator)
1925                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
1926                    return getPersistence()
1927                                       .findByC_C_T_R_S_First(classNameId, classPK, type,
1928                            receiverUserId, status, orderByComparator);
1929            }
1930    
1931            /**
1932            * Returns the first social request in the ordered set where classNameId = &#63; and classPK = &#63; and type = &#63; and receiverUserId = &#63; and status = &#63;.
1933            *
1934            * @param classNameId the class name ID
1935            * @param classPK the class p k
1936            * @param type the type
1937            * @param receiverUserId the receiver user ID
1938            * @param status the status
1939            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1940            * @return the first matching social request, or <code>null</code> if a matching social request could not be found
1941            */
1942            public static SocialRequest fetchByC_C_T_R_S_First(long classNameId,
1943                    long classPK, int type, long receiverUserId, int status,
1944                    OrderByComparator<SocialRequest> orderByComparator) {
1945                    return getPersistence()
1946                                       .fetchByC_C_T_R_S_First(classNameId, classPK, type,
1947                            receiverUserId, status, orderByComparator);
1948            }
1949    
1950            /**
1951            * Returns the last social request in the ordered set where classNameId = &#63; and classPK = &#63; and type = &#63; and receiverUserId = &#63; and status = &#63;.
1952            *
1953            * @param classNameId the class name ID
1954            * @param classPK the class p k
1955            * @param type the type
1956            * @param receiverUserId the receiver user ID
1957            * @param status the status
1958            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1959            * @return the last matching social request
1960            * @throws NoSuchRequestException if a matching social request could not be found
1961            */
1962            public static SocialRequest findByC_C_T_R_S_Last(long classNameId,
1963                    long classPK, int type, long receiverUserId, int status,
1964                    OrderByComparator<SocialRequest> orderByComparator)
1965                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
1966                    return getPersistence()
1967                                       .findByC_C_T_R_S_Last(classNameId, classPK, type,
1968                            receiverUserId, status, orderByComparator);
1969            }
1970    
1971            /**
1972            * Returns the last social request in the ordered set where classNameId = &#63; and classPK = &#63; and type = &#63; and receiverUserId = &#63; and status = &#63;.
1973            *
1974            * @param classNameId the class name ID
1975            * @param classPK the class p k
1976            * @param type the type
1977            * @param receiverUserId the receiver user ID
1978            * @param status the status
1979            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1980            * @return the last matching social request, or <code>null</code> if a matching social request could not be found
1981            */
1982            public static SocialRequest fetchByC_C_T_R_S_Last(long classNameId,
1983                    long classPK, int type, long receiverUserId, int status,
1984                    OrderByComparator<SocialRequest> orderByComparator) {
1985                    return getPersistence()
1986                                       .fetchByC_C_T_R_S_Last(classNameId, classPK, type,
1987                            receiverUserId, status, orderByComparator);
1988            }
1989    
1990            /**
1991            * Returns the social requests before and after the current social request in the ordered set where classNameId = &#63; and classPK = &#63; and type = &#63; and receiverUserId = &#63; and status = &#63;.
1992            *
1993            * @param requestId the primary key of the current social request
1994            * @param classNameId the class name ID
1995            * @param classPK the class p k
1996            * @param type the type
1997            * @param receiverUserId the receiver user ID
1998            * @param status the status
1999            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2000            * @return the previous, current, and next social request
2001            * @throws NoSuchRequestException if a social request with the primary key could not be found
2002            */
2003            public static SocialRequest[] findByC_C_T_R_S_PrevAndNext(long requestId,
2004                    long classNameId, long classPK, int type, long receiverUserId,
2005                    int status, OrderByComparator<SocialRequest> orderByComparator)
2006                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
2007                    return getPersistence()
2008                                       .findByC_C_T_R_S_PrevAndNext(requestId, classNameId,
2009                            classPK, type, receiverUserId, status, orderByComparator);
2010            }
2011    
2012            /**
2013            * Removes all the social requests where classNameId = &#63; and classPK = &#63; and type = &#63; and receiverUserId = &#63; and status = &#63; from the database.
2014            *
2015            * @param classNameId the class name ID
2016            * @param classPK the class p k
2017            * @param type the type
2018            * @param receiverUserId the receiver user ID
2019            * @param status the status
2020            */
2021            public static void removeByC_C_T_R_S(long classNameId, long classPK,
2022                    int type, long receiverUserId, int status) {
2023                    getPersistence()
2024                            .removeByC_C_T_R_S(classNameId, classPK, type, receiverUserId,
2025                            status);
2026            }
2027    
2028            /**
2029            * Returns the number of social requests where classNameId = &#63; and classPK = &#63; and type = &#63; and receiverUserId = &#63; and status = &#63;.
2030            *
2031            * @param classNameId the class name ID
2032            * @param classPK the class p k
2033            * @param type the type
2034            * @param receiverUserId the receiver user ID
2035            * @param status the status
2036            * @return the number of matching social requests
2037            */
2038            public static int countByC_C_T_R_S(long classNameId, long classPK,
2039                    int type, long receiverUserId, int status) {
2040                    return getPersistence()
2041                                       .countByC_C_T_R_S(classNameId, classPK, type,
2042                            receiverUserId, status);
2043            }
2044    
2045            /**
2046            * Caches the social request in the entity cache if it is enabled.
2047            *
2048            * @param socialRequest the social request
2049            */
2050            public static void cacheResult(SocialRequest socialRequest) {
2051                    getPersistence().cacheResult(socialRequest);
2052            }
2053    
2054            /**
2055            * Caches the social requests in the entity cache if it is enabled.
2056            *
2057            * @param socialRequests the social requests
2058            */
2059            public static void cacheResult(List<SocialRequest> socialRequests) {
2060                    getPersistence().cacheResult(socialRequests);
2061            }
2062    
2063            /**
2064            * Creates a new social request with the primary key. Does not add the social request to the database.
2065            *
2066            * @param requestId the primary key for the new social request
2067            * @return the new social request
2068            */
2069            public static SocialRequest create(long requestId) {
2070                    return getPersistence().create(requestId);
2071            }
2072    
2073            /**
2074            * Removes the social request with the primary key from the database. Also notifies the appropriate model listeners.
2075            *
2076            * @param requestId the primary key of the social request
2077            * @return the social request that was removed
2078            * @throws NoSuchRequestException if a social request with the primary key could not be found
2079            */
2080            public static SocialRequest remove(long requestId)
2081                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
2082                    return getPersistence().remove(requestId);
2083            }
2084    
2085            public static SocialRequest updateImpl(SocialRequest socialRequest) {
2086                    return getPersistence().updateImpl(socialRequest);
2087            }
2088    
2089            /**
2090            * Returns the social request with the primary key or throws a {@link NoSuchRequestException} if it could not be found.
2091            *
2092            * @param requestId the primary key of the social request
2093            * @return the social request
2094            * @throws NoSuchRequestException if a social request with the primary key could not be found
2095            */
2096            public static SocialRequest findByPrimaryKey(long requestId)
2097                    throws com.liferay.portlet.social.exception.NoSuchRequestException {
2098                    return getPersistence().findByPrimaryKey(requestId);
2099            }
2100    
2101            /**
2102            * Returns the social request with the primary key or returns <code>null</code> if it could not be found.
2103            *
2104            * @param requestId the primary key of the social request
2105            * @return the social request, or <code>null</code> if a social request with the primary key could not be found
2106            */
2107            public static SocialRequest fetchByPrimaryKey(long requestId) {
2108                    return getPersistence().fetchByPrimaryKey(requestId);
2109            }
2110    
2111            public static java.util.Map<java.io.Serializable, SocialRequest> fetchByPrimaryKeys(
2112                    java.util.Set<java.io.Serializable> primaryKeys) {
2113                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
2114            }
2115    
2116            /**
2117            * Returns all the social requests.
2118            *
2119            * @return the social requests
2120            */
2121            public static List<SocialRequest> findAll() {
2122                    return getPersistence().findAll();
2123            }
2124    
2125            /**
2126            * Returns a range of all the social requests.
2127            *
2128            * <p>
2129            * 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 SocialRequestModelImpl}. 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.
2130            * </p>
2131            *
2132            * @param start the lower bound of the range of social requests
2133            * @param end the upper bound of the range of social requests (not inclusive)
2134            * @return the range of social requests
2135            */
2136            public static List<SocialRequest> findAll(int start, int end) {
2137                    return getPersistence().findAll(start, end);
2138            }
2139    
2140            /**
2141            * Returns an ordered range of all the social requests.
2142            *
2143            * <p>
2144            * 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 SocialRequestModelImpl}. 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.
2145            * </p>
2146            *
2147            * @param start the lower bound of the range of social requests
2148            * @param end the upper bound of the range of social requests (not inclusive)
2149            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2150            * @return the ordered range of social requests
2151            */
2152            public static List<SocialRequest> findAll(int start, int end,
2153                    OrderByComparator<SocialRequest> orderByComparator) {
2154                    return getPersistence().findAll(start, end, orderByComparator);
2155            }
2156    
2157            /**
2158            * Returns an ordered range of all the social requests.
2159            *
2160            * <p>
2161            * 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 SocialRequestModelImpl}. 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.
2162            * </p>
2163            *
2164            * @param start the lower bound of the range of social requests
2165            * @param end the upper bound of the range of social requests (not inclusive)
2166            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2167            * @param retrieveFromCache whether to retrieve from the finder cache
2168            * @return the ordered range of social requests
2169            */
2170            public static List<SocialRequest> findAll(int start, int end,
2171                    OrderByComparator<SocialRequest> orderByComparator,
2172                    boolean retrieveFromCache) {
2173                    return getPersistence()
2174                                       .findAll(start, end, orderByComparator, retrieveFromCache);
2175            }
2176    
2177            /**
2178            * Removes all the social requests from the database.
2179            */
2180            public static void removeAll() {
2181                    getPersistence().removeAll();
2182            }
2183    
2184            /**
2185            * Returns the number of social requests.
2186            *
2187            * @return the number of social requests
2188            */
2189            public static int countAll() {
2190                    return getPersistence().countAll();
2191            }
2192    
2193            public static java.util.Set<java.lang.String> getBadColumnNames() {
2194                    return getPersistence().getBadColumnNames();
2195            }
2196    
2197            public static SocialRequestPersistence getPersistence() {
2198                    if (_persistence == null) {
2199                            _persistence = (SocialRequestPersistence)PortalBeanLocatorUtil.locate(SocialRequestPersistence.class.getName());
2200    
2201                            ReferenceRegistry.registerReference(SocialRequestUtil.class,
2202                                    "_persistence");
2203                    }
2204    
2205                    return _persistence;
2206            }
2207    
2208            private static SocialRequestPersistence _persistence;
2209    }