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