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