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