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