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