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