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