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 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            * Removes all the background tasks where groupId = &#63; and taskExecutorClassName = &#63; from the database.
758            *
759            * @param groupId the group ID
760            * @param taskExecutorClassName the task executor class name
761            * @throws SystemException if a system exception occurred
762            */
763            public static void removeByG_T(long groupId,
764                    java.lang.String taskExecutorClassName)
765                    throws com.liferay.portal.kernel.exception.SystemException {
766                    getPersistence().removeByG_T(groupId, taskExecutorClassName);
767            }
768    
769            /**
770            * Returns the number of background tasks where groupId = &#63; and taskExecutorClassName = &#63;.
771            *
772            * @param groupId the group ID
773            * @param taskExecutorClassName the task executor class name
774            * @return the number of matching background tasks
775            * @throws SystemException if a system exception occurred
776            */
777            public static int countByG_T(long groupId,
778                    java.lang.String taskExecutorClassName)
779                    throws com.liferay.portal.kernel.exception.SystemException {
780                    return getPersistence().countByG_T(groupId, taskExecutorClassName);
781            }
782    
783            /**
784            * Returns all the background tasks where groupId = &#63; and status = &#63;.
785            *
786            * @param groupId the group ID
787            * @param status the status
788            * @return the matching background tasks
789            * @throws SystemException if a system exception occurred
790            */
791            public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_S(
792                    long groupId, int status)
793                    throws com.liferay.portal.kernel.exception.SystemException {
794                    return getPersistence().findByG_S(groupId, status);
795            }
796    
797            /**
798            * Returns a range of all the background tasks where groupId = &#63; and status = &#63;.
799            *
800            * <p>
801            * 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.
802            * </p>
803            *
804            * @param groupId the group ID
805            * @param status the status
806            * @param start the lower bound of the range of background tasks
807            * @param end the upper bound of the range of background tasks (not inclusive)
808            * @return the range of matching background tasks
809            * @throws SystemException if a system exception occurred
810            */
811            public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_S(
812                    long groupId, int status, int start, int end)
813                    throws com.liferay.portal.kernel.exception.SystemException {
814                    return getPersistence().findByG_S(groupId, status, start, end);
815            }
816    
817            /**
818            * Returns an ordered range of all the background tasks where groupId = &#63; and status = &#63;.
819            *
820            * <p>
821            * 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.
822            * </p>
823            *
824            * @param groupId the group ID
825            * @param status the status
826            * @param start the lower bound of the range of background tasks
827            * @param end the upper bound of the range of background tasks (not inclusive)
828            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
829            * @return the ordered range of matching background tasks
830            * @throws SystemException if a system exception occurred
831            */
832            public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_S(
833                    long groupId, int status, int start, int end,
834                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
835                    throws com.liferay.portal.kernel.exception.SystemException {
836                    return getPersistence()
837                                       .findByG_S(groupId, status, start, end, orderByComparator);
838            }
839    
840            /**
841            * Returns the first background task in the ordered set where groupId = &#63; and status = &#63;.
842            *
843            * @param groupId the group ID
844            * @param status the status
845            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
846            * @return the first matching background task
847            * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found
848            * @throws SystemException if a system exception occurred
849            */
850            public static com.liferay.portal.model.BackgroundTask findByG_S_First(
851                    long groupId, int status,
852                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
853                    throws com.liferay.portal.NoSuchBackgroundTaskException,
854                            com.liferay.portal.kernel.exception.SystemException {
855                    return getPersistence()
856                                       .findByG_S_First(groupId, status, orderByComparator);
857            }
858    
859            /**
860            * Returns the first background task in the ordered set where groupId = &#63; and status = &#63;.
861            *
862            * @param groupId the group ID
863            * @param status the status
864            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
865            * @return the first matching background task, or <code>null</code> if a matching background task could not be found
866            * @throws SystemException if a system exception occurred
867            */
868            public static com.liferay.portal.model.BackgroundTask fetchByG_S_First(
869                    long groupId, int status,
870                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
871                    throws com.liferay.portal.kernel.exception.SystemException {
872                    return getPersistence()
873                                       .fetchByG_S_First(groupId, status, orderByComparator);
874            }
875    
876            /**
877            * Returns the last background task in the ordered set where groupId = &#63; and status = &#63;.
878            *
879            * @param groupId the group ID
880            * @param status the status
881            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
882            * @return the last matching background task
883            * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found
884            * @throws SystemException if a system exception occurred
885            */
886            public static com.liferay.portal.model.BackgroundTask findByG_S_Last(
887                    long groupId, int status,
888                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
889                    throws com.liferay.portal.NoSuchBackgroundTaskException,
890                            com.liferay.portal.kernel.exception.SystemException {
891                    return getPersistence()
892                                       .findByG_S_Last(groupId, status, orderByComparator);
893            }
894    
895            /**
896            * Returns the last background task in the ordered set where groupId = &#63; and status = &#63;.
897            *
898            * @param groupId the group ID
899            * @param status the status
900            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
901            * @return the last matching background task, or <code>null</code> if a matching background task could not be found
902            * @throws SystemException if a system exception occurred
903            */
904            public static com.liferay.portal.model.BackgroundTask fetchByG_S_Last(
905                    long groupId, int status,
906                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
907                    throws com.liferay.portal.kernel.exception.SystemException {
908                    return getPersistence()
909                                       .fetchByG_S_Last(groupId, status, orderByComparator);
910            }
911    
912            /**
913            * Returns the background tasks before and after the current background task in the ordered set where groupId = &#63; and status = &#63;.
914            *
915            * @param backgroundTaskId the primary key of the current background task
916            * @param groupId the group ID
917            * @param status the status
918            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
919            * @return the previous, current, and next background task
920            * @throws com.liferay.portal.NoSuchBackgroundTaskException if a background task with the primary key could not be found
921            * @throws SystemException if a system exception occurred
922            */
923            public static com.liferay.portal.model.BackgroundTask[] findByG_S_PrevAndNext(
924                    long backgroundTaskId, long groupId, int status,
925                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
926                    throws com.liferay.portal.NoSuchBackgroundTaskException,
927                            com.liferay.portal.kernel.exception.SystemException {
928                    return getPersistence()
929                                       .findByG_S_PrevAndNext(backgroundTaskId, groupId, status,
930                            orderByComparator);
931            }
932    
933            /**
934            * Removes all the background tasks where groupId = &#63; and status = &#63; from the database.
935            *
936            * @param groupId the group ID
937            * @param status the status
938            * @throws SystemException if a system exception occurred
939            */
940            public static void removeByG_S(long groupId, int status)
941                    throws com.liferay.portal.kernel.exception.SystemException {
942                    getPersistence().removeByG_S(groupId, status);
943            }
944    
945            /**
946            * Returns the number of background tasks where groupId = &#63; and status = &#63;.
947            *
948            * @param groupId the group ID
949            * @param status the status
950            * @return the number of matching background tasks
951            * @throws SystemException if a system exception occurred
952            */
953            public static int countByG_S(long groupId, int status)
954                    throws com.liferay.portal.kernel.exception.SystemException {
955                    return getPersistence().countByG_S(groupId, status);
956            }
957    
958            /**
959            * Returns all the background tasks where taskExecutorClassName = &#63; and status = &#63;.
960            *
961            * @param taskExecutorClassName the task executor class name
962            * @param status the status
963            * @return the matching background tasks
964            * @throws SystemException if a system exception occurred
965            */
966            public static java.util.List<com.liferay.portal.model.BackgroundTask> findByT_S(
967                    java.lang.String taskExecutorClassName, int status)
968                    throws com.liferay.portal.kernel.exception.SystemException {
969                    return getPersistence().findByT_S(taskExecutorClassName, status);
970            }
971    
972            /**
973            * Returns a range of all the background tasks where taskExecutorClassName = &#63; and status = &#63;.
974            *
975            * <p>
976            * 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.
977            * </p>
978            *
979            * @param taskExecutorClassName the task executor class name
980            * @param status the status
981            * @param start the lower bound of the range of background tasks
982            * @param end the upper bound of the range of background tasks (not inclusive)
983            * @return the range of matching background tasks
984            * @throws SystemException if a system exception occurred
985            */
986            public static java.util.List<com.liferay.portal.model.BackgroundTask> findByT_S(
987                    java.lang.String taskExecutorClassName, int status, int start, int end)
988                    throws com.liferay.portal.kernel.exception.SystemException {
989                    return getPersistence()
990                                       .findByT_S(taskExecutorClassName, status, start, end);
991            }
992    
993            /**
994            * Returns an ordered range of all the background tasks where taskExecutorClassName = &#63; and status = &#63;.
995            *
996            * <p>
997            * 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.
998            * </p>
999            *
1000            * @param taskExecutorClassName the task executor class name
1001            * @param status the status
1002            * @param start the lower bound of the range of background tasks
1003            * @param end the upper bound of the range of background tasks (not inclusive)
1004            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1005            * @return the ordered range of matching background tasks
1006            * @throws SystemException if a system exception occurred
1007            */
1008            public static java.util.List<com.liferay.portal.model.BackgroundTask> findByT_S(
1009                    java.lang.String taskExecutorClassName, int status, int start, int end,
1010                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1011                    throws com.liferay.portal.kernel.exception.SystemException {
1012                    return getPersistence()
1013                                       .findByT_S(taskExecutorClassName, status, start, end,
1014                            orderByComparator);
1015            }
1016    
1017            /**
1018            * Returns the first background task in the ordered set where taskExecutorClassName = &#63; and status = &#63;.
1019            *
1020            * @param taskExecutorClassName the task executor class name
1021            * @param status the status
1022            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1023            * @return the first matching background task
1024            * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found
1025            * @throws SystemException if a system exception occurred
1026            */
1027            public static com.liferay.portal.model.BackgroundTask findByT_S_First(
1028                    java.lang.String taskExecutorClassName, int status,
1029                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1030                    throws com.liferay.portal.NoSuchBackgroundTaskException,
1031                            com.liferay.portal.kernel.exception.SystemException {
1032                    return getPersistence()
1033                                       .findByT_S_First(taskExecutorClassName, status,
1034                            orderByComparator);
1035            }
1036    
1037            /**
1038            * Returns the first background task in the ordered set where taskExecutorClassName = &#63; and status = &#63;.
1039            *
1040            * @param taskExecutorClassName the task executor class name
1041            * @param status the status
1042            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1043            * @return the first matching background task, or <code>null</code> if a matching background task could not be found
1044            * @throws SystemException if a system exception occurred
1045            */
1046            public static com.liferay.portal.model.BackgroundTask fetchByT_S_First(
1047                    java.lang.String taskExecutorClassName, int status,
1048                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1049                    throws com.liferay.portal.kernel.exception.SystemException {
1050                    return getPersistence()
1051                                       .fetchByT_S_First(taskExecutorClassName, status,
1052                            orderByComparator);
1053            }
1054    
1055            /**
1056            * Returns the last background task in the ordered set where taskExecutorClassName = &#63; and status = &#63;.
1057            *
1058            * @param taskExecutorClassName the task executor class name
1059            * @param status the status
1060            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1061            * @return the last matching background task
1062            * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found
1063            * @throws SystemException if a system exception occurred
1064            */
1065            public static com.liferay.portal.model.BackgroundTask findByT_S_Last(
1066                    java.lang.String taskExecutorClassName, int status,
1067                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1068                    throws com.liferay.portal.NoSuchBackgroundTaskException,
1069                            com.liferay.portal.kernel.exception.SystemException {
1070                    return getPersistence()
1071                                       .findByT_S_Last(taskExecutorClassName, status,
1072                            orderByComparator);
1073            }
1074    
1075            /**
1076            * Returns the last background task in the ordered set where taskExecutorClassName = &#63; and status = &#63;.
1077            *
1078            * @param taskExecutorClassName the task executor class name
1079            * @param status the status
1080            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1081            * @return the last matching background task, or <code>null</code> if a matching background task could not be found
1082            * @throws SystemException if a system exception occurred
1083            */
1084            public static com.liferay.portal.model.BackgroundTask fetchByT_S_Last(
1085                    java.lang.String taskExecutorClassName, int status,
1086                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1087                    throws com.liferay.portal.kernel.exception.SystemException {
1088                    return getPersistence()
1089                                       .fetchByT_S_Last(taskExecutorClassName, status,
1090                            orderByComparator);
1091            }
1092    
1093            /**
1094            * Returns the background tasks before and after the current background task in the ordered set where taskExecutorClassName = &#63; and status = &#63;.
1095            *
1096            * @param backgroundTaskId the primary key of the current background task
1097            * @param taskExecutorClassName the task executor class name
1098            * @param status the status
1099            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1100            * @return the previous, current, and next background task
1101            * @throws com.liferay.portal.NoSuchBackgroundTaskException if a background task with the primary key could not be found
1102            * @throws SystemException if a system exception occurred
1103            */
1104            public static com.liferay.portal.model.BackgroundTask[] findByT_S_PrevAndNext(
1105                    long backgroundTaskId, java.lang.String taskExecutorClassName,
1106                    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_PrevAndNext(backgroundTaskId,
1112                            taskExecutorClassName, status, orderByComparator);
1113            }
1114    
1115            /**
1116            * Removes all the background tasks where taskExecutorClassName = &#63; and status = &#63; from the database.
1117            *
1118            * @param taskExecutorClassName the task executor class name
1119            * @param status the status
1120            * @throws SystemException if a system exception occurred
1121            */
1122            public static void removeByT_S(java.lang.String taskExecutorClassName,
1123                    int status) throws com.liferay.portal.kernel.exception.SystemException {
1124                    getPersistence().removeByT_S(taskExecutorClassName, status);
1125            }
1126    
1127            /**
1128            * Returns the number of background tasks where taskExecutorClassName = &#63; and status = &#63;.
1129            *
1130            * @param taskExecutorClassName the task executor class name
1131            * @param status the status
1132            * @return the number of matching background tasks
1133            * @throws SystemException if a system exception occurred
1134            */
1135            public static int countByT_S(java.lang.String taskExecutorClassName,
1136                    int status) throws com.liferay.portal.kernel.exception.SystemException {
1137                    return getPersistence().countByT_S(taskExecutorClassName, status);
1138            }
1139    
1140            /**
1141            * Returns all the background tasks where groupId = &#63; and name = &#63; and taskExecutorClassName = &#63;.
1142            *
1143            * @param groupId the group ID
1144            * @param name the name
1145            * @param taskExecutorClassName the task executor class name
1146            * @return the matching background tasks
1147            * @throws SystemException if a system exception occurred
1148            */
1149            public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_N_T(
1150                    long groupId, java.lang.String name,
1151                    java.lang.String taskExecutorClassName)
1152                    throws com.liferay.portal.kernel.exception.SystemException {
1153                    return getPersistence().findByG_N_T(groupId, name, taskExecutorClassName);
1154            }
1155    
1156            /**
1157            * Returns a range of all the background tasks where groupId = &#63; and name = &#63; and taskExecutorClassName = &#63;.
1158            *
1159            * <p>
1160            * 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.
1161            * </p>
1162            *
1163            * @param groupId the group ID
1164            * @param name the name
1165            * @param taskExecutorClassName the task executor class name
1166            * @param start the lower bound of the range of background tasks
1167            * @param end the upper bound of the range of background tasks (not inclusive)
1168            * @return the range of matching background tasks
1169            * @throws SystemException if a system exception occurred
1170            */
1171            public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_N_T(
1172                    long groupId, java.lang.String name,
1173                    java.lang.String taskExecutorClassName, int start, int end)
1174                    throws com.liferay.portal.kernel.exception.SystemException {
1175                    return getPersistence()
1176                                       .findByG_N_T(groupId, name, taskExecutorClassName, start, end);
1177            }
1178    
1179            /**
1180            * Returns an ordered range of all the background tasks where groupId = &#63; and name = &#63; and taskExecutorClassName = &#63;.
1181            *
1182            * <p>
1183            * 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.
1184            * </p>
1185            *
1186            * @param groupId the group ID
1187            * @param name the name
1188            * @param taskExecutorClassName the task executor class name
1189            * @param start the lower bound of the range of background tasks
1190            * @param end the upper bound of the range of background tasks (not inclusive)
1191            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1192            * @return the ordered range of matching background tasks
1193            * @throws SystemException if a system exception occurred
1194            */
1195            public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_N_T(
1196                    long groupId, java.lang.String name,
1197                    java.lang.String taskExecutorClassName, int start, int end,
1198                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1199                    throws com.liferay.portal.kernel.exception.SystemException {
1200                    return getPersistence()
1201                                       .findByG_N_T(groupId, name, taskExecutorClassName, start,
1202                            end, orderByComparator);
1203            }
1204    
1205            /**
1206            * Returns the first background task in the ordered set where groupId = &#63; and name = &#63; and taskExecutorClassName = &#63;.
1207            *
1208            * @param groupId the group ID
1209            * @param name the name
1210            * @param taskExecutorClassName the task executor class name
1211            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1212            * @return the first matching background task
1213            * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found
1214            * @throws SystemException if a system exception occurred
1215            */
1216            public static com.liferay.portal.model.BackgroundTask findByG_N_T_First(
1217                    long groupId, java.lang.String name,
1218                    java.lang.String taskExecutorClassName,
1219                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1220                    throws com.liferay.portal.NoSuchBackgroundTaskException,
1221                            com.liferay.portal.kernel.exception.SystemException {
1222                    return getPersistence()
1223                                       .findByG_N_T_First(groupId, name, taskExecutorClassName,
1224                            orderByComparator);
1225            }
1226    
1227            /**
1228            * Returns the first background task in the ordered set where groupId = &#63; and name = &#63; and taskExecutorClassName = &#63;.
1229            *
1230            * @param groupId the group ID
1231            * @param name the name
1232            * @param taskExecutorClassName the task executor class name
1233            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1234            * @return the first matching background task, or <code>null</code> if a matching background task could not be found
1235            * @throws SystemException if a system exception occurred
1236            */
1237            public static com.liferay.portal.model.BackgroundTask fetchByG_N_T_First(
1238                    long groupId, java.lang.String name,
1239                    java.lang.String taskExecutorClassName,
1240                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1241                    throws com.liferay.portal.kernel.exception.SystemException {
1242                    return getPersistence()
1243                                       .fetchByG_N_T_First(groupId, name, taskExecutorClassName,
1244                            orderByComparator);
1245            }
1246    
1247            /**
1248            * Returns the last background task in the ordered set where groupId = &#63; and name = &#63; and taskExecutorClassName = &#63;.
1249            *
1250            * @param groupId the group ID
1251            * @param name the name
1252            * @param taskExecutorClassName the task executor class name
1253            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1254            * @return the last matching background task
1255            * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found
1256            * @throws SystemException if a system exception occurred
1257            */
1258            public static com.liferay.portal.model.BackgroundTask findByG_N_T_Last(
1259                    long groupId, java.lang.String name,
1260                    java.lang.String taskExecutorClassName,
1261                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1262                    throws com.liferay.portal.NoSuchBackgroundTaskException,
1263                            com.liferay.portal.kernel.exception.SystemException {
1264                    return getPersistence()
1265                                       .findByG_N_T_Last(groupId, name, taskExecutorClassName,
1266                            orderByComparator);
1267            }
1268    
1269            /**
1270            * Returns the last background task in the ordered set where groupId = &#63; and name = &#63; and taskExecutorClassName = &#63;.
1271            *
1272            * @param groupId the group ID
1273            * @param name the name
1274            * @param taskExecutorClassName the task executor class name
1275            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1276            * @return the last matching background task, or <code>null</code> if a matching background task could not be found
1277            * @throws SystemException if a system exception occurred
1278            */
1279            public static com.liferay.portal.model.BackgroundTask fetchByG_N_T_Last(
1280                    long groupId, java.lang.String name,
1281                    java.lang.String taskExecutorClassName,
1282                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1283                    throws com.liferay.portal.kernel.exception.SystemException {
1284                    return getPersistence()
1285                                       .fetchByG_N_T_Last(groupId, name, taskExecutorClassName,
1286                            orderByComparator);
1287            }
1288    
1289            /**
1290            * Returns the background tasks before and after the current background task in the ordered set where groupId = &#63; and name = &#63; and taskExecutorClassName = &#63;.
1291            *
1292            * @param backgroundTaskId the primary key of the current background task
1293            * @param groupId the group ID
1294            * @param name the name
1295            * @param taskExecutorClassName the task executor class name
1296            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1297            * @return the previous, current, and next background task
1298            * @throws com.liferay.portal.NoSuchBackgroundTaskException if a background task with the primary key could not be found
1299            * @throws SystemException if a system exception occurred
1300            */
1301            public static com.liferay.portal.model.BackgroundTask[] findByG_N_T_PrevAndNext(
1302                    long backgroundTaskId, long groupId, java.lang.String name,
1303                    java.lang.String taskExecutorClassName,
1304                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1305                    throws com.liferay.portal.NoSuchBackgroundTaskException,
1306                            com.liferay.portal.kernel.exception.SystemException {
1307                    return getPersistence()
1308                                       .findByG_N_T_PrevAndNext(backgroundTaskId, groupId, name,
1309                            taskExecutorClassName, orderByComparator);
1310            }
1311    
1312            /**
1313            * Removes all the background tasks where groupId = &#63; and name = &#63; and taskExecutorClassName = &#63; from the database.
1314            *
1315            * @param groupId the group ID
1316            * @param name the name
1317            * @param taskExecutorClassName the task executor class name
1318            * @throws SystemException if a system exception occurred
1319            */
1320            public static void removeByG_N_T(long groupId, java.lang.String name,
1321                    java.lang.String taskExecutorClassName)
1322                    throws com.liferay.portal.kernel.exception.SystemException {
1323                    getPersistence().removeByG_N_T(groupId, name, taskExecutorClassName);
1324            }
1325    
1326            /**
1327            * Returns the number of background tasks where groupId = &#63; and name = &#63; and taskExecutorClassName = &#63;.
1328            *
1329            * @param groupId the group ID
1330            * @param name the name
1331            * @param taskExecutorClassName the task executor class name
1332            * @return the number of matching background tasks
1333            * @throws SystemException if a system exception occurred
1334            */
1335            public static int countByG_N_T(long groupId, java.lang.String name,
1336                    java.lang.String taskExecutorClassName)
1337                    throws com.liferay.portal.kernel.exception.SystemException {
1338                    return getPersistence()
1339                                       .countByG_N_T(groupId, name, taskExecutorClassName);
1340            }
1341    
1342            /**
1343            * Returns all the background tasks where groupId = &#63; and taskExecutorClassName = &#63; and completed = &#63;.
1344            *
1345            * @param groupId the group ID
1346            * @param taskExecutorClassName the task executor class name
1347            * @param completed the completed
1348            * @return the matching background tasks
1349            * @throws SystemException if a system exception occurred
1350            */
1351            public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T_C(
1352                    long groupId, java.lang.String taskExecutorClassName, boolean completed)
1353                    throws com.liferay.portal.kernel.exception.SystemException {
1354                    return getPersistence()
1355                                       .findByG_T_C(groupId, taskExecutorClassName, completed);
1356            }
1357    
1358            /**
1359            * Returns a range of all the background tasks where groupId = &#63; and taskExecutorClassName = &#63; and completed = &#63;.
1360            *
1361            * <p>
1362            * 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.
1363            * </p>
1364            *
1365            * @param groupId the group ID
1366            * @param taskExecutorClassName the task executor class name
1367            * @param completed the completed
1368            * @param start the lower bound of the range of background tasks
1369            * @param end the upper bound of the range of background tasks (not inclusive)
1370            * @return the range of matching background tasks
1371            * @throws SystemException if a system exception occurred
1372            */
1373            public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T_C(
1374                    long groupId, java.lang.String taskExecutorClassName,
1375                    boolean completed, int start, int end)
1376                    throws com.liferay.portal.kernel.exception.SystemException {
1377                    return getPersistence()
1378                                       .findByG_T_C(groupId, taskExecutorClassName, completed,
1379                            start, end);
1380            }
1381    
1382            /**
1383            * Returns an ordered range of all the background tasks where groupId = &#63; and taskExecutorClassName = &#63; and completed = &#63;.
1384            *
1385            * <p>
1386            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1387            * </p>
1388            *
1389            * @param groupId the group ID
1390            * @param taskExecutorClassName the task executor class name
1391            * @param completed the completed
1392            * @param start the lower bound of the range of background tasks
1393            * @param end the upper bound of the range of background tasks (not inclusive)
1394            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1395            * @return the ordered range of matching background tasks
1396            * @throws SystemException if a system exception occurred
1397            */
1398            public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T_C(
1399                    long groupId, java.lang.String taskExecutorClassName,
1400                    boolean completed, int start, int end,
1401                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1402                    throws com.liferay.portal.kernel.exception.SystemException {
1403                    return getPersistence()
1404                                       .findByG_T_C(groupId, taskExecutorClassName, completed,
1405                            start, end, orderByComparator);
1406            }
1407    
1408            /**
1409            * Returns the first background task in the ordered set where groupId = &#63; and taskExecutorClassName = &#63; and completed = &#63;.
1410            *
1411            * @param groupId the group ID
1412            * @param taskExecutorClassName the task executor class name
1413            * @param completed the completed
1414            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1415            * @return the first matching background task
1416            * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found
1417            * @throws SystemException if a system exception occurred
1418            */
1419            public static com.liferay.portal.model.BackgroundTask findByG_T_C_First(
1420                    long groupId, java.lang.String taskExecutorClassName,
1421                    boolean completed,
1422                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1423                    throws com.liferay.portal.NoSuchBackgroundTaskException,
1424                            com.liferay.portal.kernel.exception.SystemException {
1425                    return getPersistence()
1426                                       .findByG_T_C_First(groupId, taskExecutorClassName,
1427                            completed, orderByComparator);
1428            }
1429    
1430            /**
1431            * Returns the first background task in the ordered set where groupId = &#63; and taskExecutorClassName = &#63; and completed = &#63;.
1432            *
1433            * @param groupId the group ID
1434            * @param taskExecutorClassName the task executor class name
1435            * @param completed the completed
1436            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1437            * @return the first matching background task, or <code>null</code> if a matching background task could not be found
1438            * @throws SystemException if a system exception occurred
1439            */
1440            public static com.liferay.portal.model.BackgroundTask fetchByG_T_C_First(
1441                    long groupId, java.lang.String taskExecutorClassName,
1442                    boolean completed,
1443                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1444                    throws com.liferay.portal.kernel.exception.SystemException {
1445                    return getPersistence()
1446                                       .fetchByG_T_C_First(groupId, taskExecutorClassName,
1447                            completed, orderByComparator);
1448            }
1449    
1450            /**
1451            * Returns the last background task in the ordered set where groupId = &#63; and taskExecutorClassName = &#63; and completed = &#63;.
1452            *
1453            * @param groupId the group ID
1454            * @param taskExecutorClassName the task executor class name
1455            * @param completed the completed
1456            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1457            * @return the last matching background task
1458            * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found
1459            * @throws SystemException if a system exception occurred
1460            */
1461            public static com.liferay.portal.model.BackgroundTask findByG_T_C_Last(
1462                    long groupId, java.lang.String taskExecutorClassName,
1463                    boolean completed,
1464                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1465                    throws com.liferay.portal.NoSuchBackgroundTaskException,
1466                            com.liferay.portal.kernel.exception.SystemException {
1467                    return getPersistence()
1468                                       .findByG_T_C_Last(groupId, taskExecutorClassName, completed,
1469                            orderByComparator);
1470            }
1471    
1472            /**
1473            * Returns the last background task in the ordered set where groupId = &#63; and taskExecutorClassName = &#63; and completed = &#63;.
1474            *
1475            * @param groupId the group ID
1476            * @param taskExecutorClassName the task executor class name
1477            * @param completed the completed
1478            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1479            * @return the last matching background task, or <code>null</code> if a matching background task could not be found
1480            * @throws SystemException if a system exception occurred
1481            */
1482            public static com.liferay.portal.model.BackgroundTask fetchByG_T_C_Last(
1483                    long groupId, java.lang.String taskExecutorClassName,
1484                    boolean completed,
1485                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1486                    throws com.liferay.portal.kernel.exception.SystemException {
1487                    return getPersistence()
1488                                       .fetchByG_T_C_Last(groupId, taskExecutorClassName,
1489                            completed, orderByComparator);
1490            }
1491    
1492            /**
1493            * Returns the background tasks before and after the current background task in the ordered set where groupId = &#63; and taskExecutorClassName = &#63; and completed = &#63;.
1494            *
1495            * @param backgroundTaskId the primary key of the current background task
1496            * @param groupId the group ID
1497            * @param taskExecutorClassName the task executor class name
1498            * @param completed the completed
1499            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1500            * @return the previous, current, and next background task
1501            * @throws com.liferay.portal.NoSuchBackgroundTaskException if a background task with the primary key could not be found
1502            * @throws SystemException if a system exception occurred
1503            */
1504            public static com.liferay.portal.model.BackgroundTask[] findByG_T_C_PrevAndNext(
1505                    long backgroundTaskId, long groupId,
1506                    java.lang.String taskExecutorClassName, boolean completed,
1507                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1508                    throws com.liferay.portal.NoSuchBackgroundTaskException,
1509                            com.liferay.portal.kernel.exception.SystemException {
1510                    return getPersistence()
1511                                       .findByG_T_C_PrevAndNext(backgroundTaskId, groupId,
1512                            taskExecutorClassName, completed, orderByComparator);
1513            }
1514    
1515            /**
1516            * Removes all the background tasks where groupId = &#63; and taskExecutorClassName = &#63; and completed = &#63; from the database.
1517            *
1518            * @param groupId the group ID
1519            * @param taskExecutorClassName the task executor class name
1520            * @param completed the completed
1521            * @throws SystemException if a system exception occurred
1522            */
1523            public static void removeByG_T_C(long groupId,
1524                    java.lang.String taskExecutorClassName, boolean completed)
1525                    throws com.liferay.portal.kernel.exception.SystemException {
1526                    getPersistence().removeByG_T_C(groupId, taskExecutorClassName, completed);
1527            }
1528    
1529            /**
1530            * Returns the number of background tasks where groupId = &#63; and taskExecutorClassName = &#63; and completed = &#63;.
1531            *
1532            * @param groupId the group ID
1533            * @param taskExecutorClassName the task executor class name
1534            * @param completed the completed
1535            * @return the number of matching background tasks
1536            * @throws SystemException if a system exception occurred
1537            */
1538            public static int countByG_T_C(long groupId,
1539                    java.lang.String taskExecutorClassName, boolean completed)
1540                    throws com.liferay.portal.kernel.exception.SystemException {
1541                    return getPersistence()
1542                                       .countByG_T_C(groupId, taskExecutorClassName, completed);
1543            }
1544    
1545            /**
1546            * Returns all the background tasks where groupId = &#63; and taskExecutorClassName = &#63; and status = &#63;.
1547            *
1548            * @param groupId the group ID
1549            * @param taskExecutorClassName the task executor class name
1550            * @param status the status
1551            * @return the matching background tasks
1552            * @throws SystemException if a system exception occurred
1553            */
1554            public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T_S(
1555                    long groupId, java.lang.String taskExecutorClassName, int status)
1556                    throws com.liferay.portal.kernel.exception.SystemException {
1557                    return getPersistence()
1558                                       .findByG_T_S(groupId, taskExecutorClassName, status);
1559            }
1560    
1561            /**
1562            * Returns a range of all the background tasks where groupId = &#63; and taskExecutorClassName = &#63; and status = &#63;.
1563            *
1564            * <p>
1565            * 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.
1566            * </p>
1567            *
1568            * @param groupId the group ID
1569            * @param taskExecutorClassName the task executor class name
1570            * @param status the status
1571            * @param start the lower bound of the range of background tasks
1572            * @param end the upper bound of the range of background tasks (not inclusive)
1573            * @return the range of matching background tasks
1574            * @throws SystemException if a system exception occurred
1575            */
1576            public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T_S(
1577                    long groupId, java.lang.String taskExecutorClassName, int status,
1578                    int start, int end)
1579                    throws com.liferay.portal.kernel.exception.SystemException {
1580                    return getPersistence()
1581                                       .findByG_T_S(groupId, taskExecutorClassName, status, start,
1582                            end);
1583            }
1584    
1585            /**
1586            * Returns an ordered range of all the background tasks where groupId = &#63; and taskExecutorClassName = &#63; and status = &#63;.
1587            *
1588            * <p>
1589            * 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.
1590            * </p>
1591            *
1592            * @param groupId the group ID
1593            * @param taskExecutorClassName the task executor class name
1594            * @param status the status
1595            * @param start the lower bound of the range of background tasks
1596            * @param end the upper bound of the range of background tasks (not inclusive)
1597            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1598            * @return the ordered range of matching background tasks
1599            * @throws SystemException if a system exception occurred
1600            */
1601            public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T_S(
1602                    long groupId, java.lang.String taskExecutorClassName, int status,
1603                    int start, int end,
1604                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1605                    throws com.liferay.portal.kernel.exception.SystemException {
1606                    return getPersistence()
1607                                       .findByG_T_S(groupId, taskExecutorClassName, status, start,
1608                            end, orderByComparator);
1609            }
1610    
1611            /**
1612            * Returns the first background task in the ordered set where groupId = &#63; and taskExecutorClassName = &#63; and status = &#63;.
1613            *
1614            * @param groupId the group ID
1615            * @param taskExecutorClassName the task executor class name
1616            * @param status the status
1617            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1618            * @return the first matching background task
1619            * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found
1620            * @throws SystemException if a system exception occurred
1621            */
1622            public static com.liferay.portal.model.BackgroundTask findByG_T_S_First(
1623                    long groupId, java.lang.String taskExecutorClassName, int status,
1624                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1625                    throws com.liferay.portal.NoSuchBackgroundTaskException,
1626                            com.liferay.portal.kernel.exception.SystemException {
1627                    return getPersistence()
1628                                       .findByG_T_S_First(groupId, taskExecutorClassName, status,
1629                            orderByComparator);
1630            }
1631    
1632            /**
1633            * Returns the first background task in the ordered set where groupId = &#63; and taskExecutorClassName = &#63; and status = &#63;.
1634            *
1635            * @param groupId the group ID
1636            * @param taskExecutorClassName the task executor class name
1637            * @param status the status
1638            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1639            * @return the first matching background task, or <code>null</code> if a matching background task could not be found
1640            * @throws SystemException if a system exception occurred
1641            */
1642            public static com.liferay.portal.model.BackgroundTask fetchByG_T_S_First(
1643                    long groupId, java.lang.String taskExecutorClassName, int status,
1644                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1645                    throws com.liferay.portal.kernel.exception.SystemException {
1646                    return getPersistence()
1647                                       .fetchByG_T_S_First(groupId, taskExecutorClassName, status,
1648                            orderByComparator);
1649            }
1650    
1651            /**
1652            * Returns the last background task in the ordered set where groupId = &#63; and taskExecutorClassName = &#63; and status = &#63;.
1653            *
1654            * @param groupId the group ID
1655            * @param taskExecutorClassName the task executor class name
1656            * @param status the status
1657            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1658            * @return the last matching background task
1659            * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found
1660            * @throws SystemException if a system exception occurred
1661            */
1662            public static com.liferay.portal.model.BackgroundTask findByG_T_S_Last(
1663                    long groupId, java.lang.String taskExecutorClassName, int status,
1664                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1665                    throws com.liferay.portal.NoSuchBackgroundTaskException,
1666                            com.liferay.portal.kernel.exception.SystemException {
1667                    return getPersistence()
1668                                       .findByG_T_S_Last(groupId, taskExecutorClassName, status,
1669                            orderByComparator);
1670            }
1671    
1672            /**
1673            * Returns the last background task in the ordered set where groupId = &#63; and taskExecutorClassName = &#63; and status = &#63;.
1674            *
1675            * @param groupId the group ID
1676            * @param taskExecutorClassName the task executor class name
1677            * @param status the status
1678            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1679            * @return the last matching background task, or <code>null</code> if a matching background task could not be found
1680            * @throws SystemException if a system exception occurred
1681            */
1682            public static com.liferay.portal.model.BackgroundTask fetchByG_T_S_Last(
1683                    long groupId, java.lang.String taskExecutorClassName, int status,
1684                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1685                    throws com.liferay.portal.kernel.exception.SystemException {
1686                    return getPersistence()
1687                                       .fetchByG_T_S_Last(groupId, taskExecutorClassName, status,
1688                            orderByComparator);
1689            }
1690    
1691            /**
1692            * Returns the background tasks before and after the current background task in the ordered set where groupId = &#63; and taskExecutorClassName = &#63; and status = &#63;.
1693            *
1694            * @param backgroundTaskId the primary key of the current background task
1695            * @param groupId the group ID
1696            * @param taskExecutorClassName the task executor class name
1697            * @param status the status
1698            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1699            * @return the previous, current, and next background task
1700            * @throws com.liferay.portal.NoSuchBackgroundTaskException if a background task with the primary key could not be found
1701            * @throws SystemException if a system exception occurred
1702            */
1703            public static com.liferay.portal.model.BackgroundTask[] findByG_T_S_PrevAndNext(
1704                    long backgroundTaskId, long groupId,
1705                    java.lang.String taskExecutorClassName, int status,
1706                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1707                    throws com.liferay.portal.NoSuchBackgroundTaskException,
1708                            com.liferay.portal.kernel.exception.SystemException {
1709                    return getPersistence()
1710                                       .findByG_T_S_PrevAndNext(backgroundTaskId, groupId,
1711                            taskExecutorClassName, status, orderByComparator);
1712            }
1713    
1714            /**
1715            * Removes all the background tasks where groupId = &#63; and taskExecutorClassName = &#63; and status = &#63; from the database.
1716            *
1717            * @param groupId the group ID
1718            * @param taskExecutorClassName the task executor class name
1719            * @param status the status
1720            * @throws SystemException if a system exception occurred
1721            */
1722            public static void removeByG_T_S(long groupId,
1723                    java.lang.String taskExecutorClassName, int status)
1724                    throws com.liferay.portal.kernel.exception.SystemException {
1725                    getPersistence().removeByG_T_S(groupId, taskExecutorClassName, status);
1726            }
1727    
1728            /**
1729            * Returns the number of background tasks where groupId = &#63; and taskExecutorClassName = &#63; and status = &#63;.
1730            *
1731            * @param groupId the group ID
1732            * @param taskExecutorClassName the task executor class name
1733            * @param status the status
1734            * @return the number of matching background tasks
1735            * @throws SystemException if a system exception occurred
1736            */
1737            public static int countByG_T_S(long groupId,
1738                    java.lang.String taskExecutorClassName, int status)
1739                    throws com.liferay.portal.kernel.exception.SystemException {
1740                    return getPersistence()
1741                                       .countByG_T_S(groupId, taskExecutorClassName, status);
1742            }
1743    
1744            /**
1745            * Returns all the background tasks where groupId = &#63; and name = &#63; and taskExecutorClassName = &#63; and completed = &#63;.
1746            *
1747            * @param groupId the group ID
1748            * @param name the name
1749            * @param taskExecutorClassName the task executor class name
1750            * @param completed the completed
1751            * @return the matching background tasks
1752            * @throws SystemException if a system exception occurred
1753            */
1754            public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_N_T_C(
1755                    long groupId, java.lang.String name,
1756                    java.lang.String taskExecutorClassName, boolean completed)
1757                    throws com.liferay.portal.kernel.exception.SystemException {
1758                    return getPersistence()
1759                                       .findByG_N_T_C(groupId, name, taskExecutorClassName,
1760                            completed);
1761            }
1762    
1763            /**
1764            * Returns a range of all the background tasks where groupId = &#63; and name = &#63; and taskExecutorClassName = &#63; and completed = &#63;.
1765            *
1766            * <p>
1767            * 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.
1768            * </p>
1769            *
1770            * @param groupId the group ID
1771            * @param name the name
1772            * @param taskExecutorClassName the task executor class name
1773            * @param completed the completed
1774            * @param start the lower bound of the range of background tasks
1775            * @param end the upper bound of the range of background tasks (not inclusive)
1776            * @return the range of matching background tasks
1777            * @throws SystemException if a system exception occurred
1778            */
1779            public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_N_T_C(
1780                    long groupId, java.lang.String name,
1781                    java.lang.String taskExecutorClassName, boolean completed, int start,
1782                    int end) throws com.liferay.portal.kernel.exception.SystemException {
1783                    return getPersistence()
1784                                       .findByG_N_T_C(groupId, name, taskExecutorClassName,
1785                            completed, start, end);
1786            }
1787    
1788            /**
1789            * Returns an ordered range of all the background tasks where groupId = &#63; and name = &#63; and taskExecutorClassName = &#63; and completed = &#63;.
1790            *
1791            * <p>
1792            * 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.
1793            * </p>
1794            *
1795            * @param groupId the group ID
1796            * @param name the name
1797            * @param taskExecutorClassName the task executor class name
1798            * @param completed the completed
1799            * @param start the lower bound of the range of background tasks
1800            * @param end the upper bound of the range of background tasks (not inclusive)
1801            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1802            * @return the ordered range of matching background tasks
1803            * @throws SystemException if a system exception occurred
1804            */
1805            public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_N_T_C(
1806                    long groupId, java.lang.String name,
1807                    java.lang.String taskExecutorClassName, boolean completed, int start,
1808                    int end,
1809                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1810                    throws com.liferay.portal.kernel.exception.SystemException {
1811                    return getPersistence()
1812                                       .findByG_N_T_C(groupId, name, taskExecutorClassName,
1813                            completed, start, end, orderByComparator);
1814            }
1815    
1816            /**
1817            * Returns the first background task in the ordered set where groupId = &#63; and name = &#63; and taskExecutorClassName = &#63; and completed = &#63;.
1818            *
1819            * @param groupId the group ID
1820            * @param name the name
1821            * @param taskExecutorClassName the task executor class name
1822            * @param completed the completed
1823            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1824            * @return the first matching background task
1825            * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found
1826            * @throws SystemException if a system exception occurred
1827            */
1828            public static com.liferay.portal.model.BackgroundTask findByG_N_T_C_First(
1829                    long groupId, java.lang.String name,
1830                    java.lang.String taskExecutorClassName, boolean completed,
1831                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1832                    throws com.liferay.portal.NoSuchBackgroundTaskException,
1833                            com.liferay.portal.kernel.exception.SystemException {
1834                    return getPersistence()
1835                                       .findByG_N_T_C_First(groupId, name, taskExecutorClassName,
1836                            completed, orderByComparator);
1837            }
1838    
1839            /**
1840            * Returns the first background task in the ordered set where groupId = &#63; and name = &#63; and taskExecutorClassName = &#63; and completed = &#63;.
1841            *
1842            * @param groupId the group ID
1843            * @param name the name
1844            * @param taskExecutorClassName the task executor class name
1845            * @param completed the completed
1846            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1847            * @return the first matching background task, or <code>null</code> if a matching background task could not be found
1848            * @throws SystemException if a system exception occurred
1849            */
1850            public static com.liferay.portal.model.BackgroundTask fetchByG_N_T_C_First(
1851                    long groupId, java.lang.String name,
1852                    java.lang.String taskExecutorClassName, boolean completed,
1853                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1854                    throws com.liferay.portal.kernel.exception.SystemException {
1855                    return getPersistence()
1856                                       .fetchByG_N_T_C_First(groupId, name, taskExecutorClassName,
1857                            completed, orderByComparator);
1858            }
1859    
1860            /**
1861            * Returns the last background task in the ordered set where groupId = &#63; and name = &#63; and taskExecutorClassName = &#63; and completed = &#63;.
1862            *
1863            * @param groupId the group ID
1864            * @param name the name
1865            * @param taskExecutorClassName the task executor class name
1866            * @param completed the completed
1867            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1868            * @return the last matching background task
1869            * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found
1870            * @throws SystemException if a system exception occurred
1871            */
1872            public static com.liferay.portal.model.BackgroundTask findByG_N_T_C_Last(
1873                    long groupId, java.lang.String name,
1874                    java.lang.String taskExecutorClassName, boolean completed,
1875                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1876                    throws com.liferay.portal.NoSuchBackgroundTaskException,
1877                            com.liferay.portal.kernel.exception.SystemException {
1878                    return getPersistence()
1879                                       .findByG_N_T_C_Last(groupId, name, taskExecutorClassName,
1880                            completed, orderByComparator);
1881            }
1882    
1883            /**
1884            * Returns the last background task in the ordered set where groupId = &#63; and name = &#63; and taskExecutorClassName = &#63; and completed = &#63;.
1885            *
1886            * @param groupId the group ID
1887            * @param name the name
1888            * @param taskExecutorClassName the task executor class name
1889            * @param completed the completed
1890            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1891            * @return the last matching background task, or <code>null</code> if a matching background task could not be found
1892            * @throws SystemException if a system exception occurred
1893            */
1894            public static com.liferay.portal.model.BackgroundTask fetchByG_N_T_C_Last(
1895                    long groupId, java.lang.String name,
1896                    java.lang.String taskExecutorClassName, boolean completed,
1897                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1898                    throws com.liferay.portal.kernel.exception.SystemException {
1899                    return getPersistence()
1900                                       .fetchByG_N_T_C_Last(groupId, name, taskExecutorClassName,
1901                            completed, orderByComparator);
1902            }
1903    
1904            /**
1905            * 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;.
1906            *
1907            * @param backgroundTaskId the primary key of the current background task
1908            * @param groupId the group ID
1909            * @param name the name
1910            * @param taskExecutorClassName the task executor class name
1911            * @param completed the completed
1912            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1913            * @return the previous, current, and next background task
1914            * @throws com.liferay.portal.NoSuchBackgroundTaskException if a background task with the primary key could not be found
1915            * @throws SystemException if a system exception occurred
1916            */
1917            public static com.liferay.portal.model.BackgroundTask[] findByG_N_T_C_PrevAndNext(
1918                    long backgroundTaskId, long groupId, java.lang.String name,
1919                    java.lang.String taskExecutorClassName, boolean completed,
1920                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1921                    throws com.liferay.portal.NoSuchBackgroundTaskException,
1922                            com.liferay.portal.kernel.exception.SystemException {
1923                    return getPersistence()
1924                                       .findByG_N_T_C_PrevAndNext(backgroundTaskId, groupId, name,
1925                            taskExecutorClassName, completed, orderByComparator);
1926            }
1927    
1928            /**
1929            * Removes all the background tasks where groupId = &#63; and name = &#63; and taskExecutorClassName = &#63; and completed = &#63; from the database.
1930            *
1931            * @param groupId the group ID
1932            * @param name the name
1933            * @param taskExecutorClassName the task executor class name
1934            * @param completed the completed
1935            * @throws SystemException if a system exception occurred
1936            */
1937            public static void removeByG_N_T_C(long groupId, java.lang.String name,
1938                    java.lang.String taskExecutorClassName, boolean completed)
1939                    throws com.liferay.portal.kernel.exception.SystemException {
1940                    getPersistence()
1941                            .removeByG_N_T_C(groupId, name, taskExecutorClassName, completed);
1942            }
1943    
1944            /**
1945            * Returns the number of background tasks where groupId = &#63; and name = &#63; and taskExecutorClassName = &#63; and completed = &#63;.
1946            *
1947            * @param groupId the group ID
1948            * @param name the name
1949            * @param taskExecutorClassName the task executor class name
1950            * @param completed the completed
1951            * @return the number of matching background tasks
1952            * @throws SystemException if a system exception occurred
1953            */
1954            public static int countByG_N_T_C(long groupId, java.lang.String name,
1955                    java.lang.String taskExecutorClassName, boolean completed)
1956                    throws com.liferay.portal.kernel.exception.SystemException {
1957                    return getPersistence()
1958                                       .countByG_N_T_C(groupId, name, taskExecutorClassName,
1959                            completed);
1960            }
1961    
1962            /**
1963            * Caches the background task in the entity cache if it is enabled.
1964            *
1965            * @param backgroundTask the background task
1966            */
1967            public static void cacheResult(
1968                    com.liferay.portal.model.BackgroundTask backgroundTask) {
1969                    getPersistence().cacheResult(backgroundTask);
1970            }
1971    
1972            /**
1973            * Caches the background tasks in the entity cache if it is enabled.
1974            *
1975            * @param backgroundTasks the background tasks
1976            */
1977            public static void cacheResult(
1978                    java.util.List<com.liferay.portal.model.BackgroundTask> backgroundTasks) {
1979                    getPersistence().cacheResult(backgroundTasks);
1980            }
1981    
1982            /**
1983            * Creates a new background task with the primary key. Does not add the background task to the database.
1984            *
1985            * @param backgroundTaskId the primary key for the new background task
1986            * @return the new background task
1987            */
1988            public static com.liferay.portal.model.BackgroundTask create(
1989                    long backgroundTaskId) {
1990                    return getPersistence().create(backgroundTaskId);
1991            }
1992    
1993            /**
1994            * Removes the background task with the primary key from the database. Also notifies the appropriate model listeners.
1995            *
1996            * @param backgroundTaskId the primary key of the background task
1997            * @return the background task that was removed
1998            * @throws com.liferay.portal.NoSuchBackgroundTaskException if a background task with the primary key could not be found
1999            * @throws SystemException if a system exception occurred
2000            */
2001            public static com.liferay.portal.model.BackgroundTask remove(
2002                    long backgroundTaskId)
2003                    throws com.liferay.portal.NoSuchBackgroundTaskException,
2004                            com.liferay.portal.kernel.exception.SystemException {
2005                    return getPersistence().remove(backgroundTaskId);
2006            }
2007    
2008            public static com.liferay.portal.model.BackgroundTask updateImpl(
2009                    com.liferay.portal.model.BackgroundTask backgroundTask)
2010                    throws com.liferay.portal.kernel.exception.SystemException {
2011                    return getPersistence().updateImpl(backgroundTask);
2012            }
2013    
2014            /**
2015            * Returns the background task with the primary key or throws a {@link com.liferay.portal.NoSuchBackgroundTaskException} if it could not be found.
2016            *
2017            * @param backgroundTaskId the primary key of the background task
2018            * @return the background task
2019            * @throws com.liferay.portal.NoSuchBackgroundTaskException if a background task with the primary key could not be found
2020            * @throws SystemException if a system exception occurred
2021            */
2022            public static com.liferay.portal.model.BackgroundTask findByPrimaryKey(
2023                    long backgroundTaskId)
2024                    throws com.liferay.portal.NoSuchBackgroundTaskException,
2025                            com.liferay.portal.kernel.exception.SystemException {
2026                    return getPersistence().findByPrimaryKey(backgroundTaskId);
2027            }
2028    
2029            /**
2030            * Returns the background task with the primary key or returns <code>null</code> if it could not be found.
2031            *
2032            * @param backgroundTaskId the primary key of the background task
2033            * @return the background task, or <code>null</code> if a background task with the primary key could not be found
2034            * @throws SystemException if a system exception occurred
2035            */
2036            public static com.liferay.portal.model.BackgroundTask fetchByPrimaryKey(
2037                    long backgroundTaskId)
2038                    throws com.liferay.portal.kernel.exception.SystemException {
2039                    return getPersistence().fetchByPrimaryKey(backgroundTaskId);
2040            }
2041    
2042            /**
2043            * Returns all the background tasks.
2044            *
2045            * @return the background tasks
2046            * @throws SystemException if a system exception occurred
2047            */
2048            public static java.util.List<com.liferay.portal.model.BackgroundTask> findAll()
2049                    throws com.liferay.portal.kernel.exception.SystemException {
2050                    return getPersistence().findAll();
2051            }
2052    
2053            /**
2054            * Returns a range of all the background tasks.
2055            *
2056            * <p>
2057            * 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.
2058            * </p>
2059            *
2060            * @param start the lower bound of the range of background tasks
2061            * @param end the upper bound of the range of background tasks (not inclusive)
2062            * @return the range of background tasks
2063            * @throws SystemException if a system exception occurred
2064            */
2065            public static java.util.List<com.liferay.portal.model.BackgroundTask> findAll(
2066                    int start, int end)
2067                    throws com.liferay.portal.kernel.exception.SystemException {
2068                    return getPersistence().findAll(start, end);
2069            }
2070    
2071            /**
2072            * Returns an ordered range of all the background tasks.
2073            *
2074            * <p>
2075            * 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.
2076            * </p>
2077            *
2078            * @param start the lower bound of the range of background tasks
2079            * @param end the upper bound of the range of background tasks (not inclusive)
2080            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2081            * @return the ordered range of background tasks
2082            * @throws SystemException if a system exception occurred
2083            */
2084            public static java.util.List<com.liferay.portal.model.BackgroundTask> findAll(
2085                    int start, int end,
2086                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2087                    throws com.liferay.portal.kernel.exception.SystemException {
2088                    return getPersistence().findAll(start, end, orderByComparator);
2089            }
2090    
2091            /**
2092            * Removes all the background tasks from the database.
2093            *
2094            * @throws SystemException if a system exception occurred
2095            */
2096            public static void removeAll()
2097                    throws com.liferay.portal.kernel.exception.SystemException {
2098                    getPersistence().removeAll();
2099            }
2100    
2101            /**
2102            * Returns the number of background tasks.
2103            *
2104            * @return the number of background tasks
2105            * @throws SystemException if a system exception occurred
2106            */
2107            public static int countAll()
2108                    throws com.liferay.portal.kernel.exception.SystemException {
2109                    return getPersistence().countAll();
2110            }
2111    
2112            public static BackgroundTaskPersistence getPersistence() {
2113                    if (_persistence == null) {
2114                            _persistence = (BackgroundTaskPersistence)PortalBeanLocatorUtil.locate(BackgroundTaskPersistence.class.getName());
2115    
2116                            ReferenceRegistry.registerReference(BackgroundTaskUtil.class,
2117                                    "_persistence");
2118                    }
2119    
2120                    return _persistence;
2121            }
2122    
2123            /**
2124             * @deprecated As of 6.2.0
2125             */
2126            public void setPersistence(BackgroundTaskPersistence persistence) {
2127            }
2128    
2129            private static BackgroundTaskPersistence _persistence;
2130    }