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