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