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