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.portlet.exportimport.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.service.ServiceContext; 024 025 import com.liferay.portlet.exportimport.model.ExportImportConfiguration; 026 027 import java.util.List; 028 029 /** 030 * The persistence utility for the export import configuration service. This utility wraps {@link com.liferay.portlet.exportimport.service.persistence.impl.ExportImportConfigurationPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 031 * 032 * <p> 033 * Caching information and settings can be found in <code>portal.properties</code> 034 * </p> 035 * 036 * @author Brian Wing Shun Chan 037 * @see ExportImportConfigurationPersistence 038 * @see com.liferay.portlet.exportimport.service.persistence.impl.ExportImportConfigurationPersistenceImpl 039 * @generated 040 */ 041 @ProviderType 042 public class ExportImportConfigurationUtil { 043 /* 044 * NOTE FOR DEVELOPERS: 045 * 046 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 047 */ 048 049 /** 050 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 051 */ 052 public static void clearCache() { 053 getPersistence().clearCache(); 054 } 055 056 /** 057 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 058 */ 059 public static void clearCache( 060 ExportImportConfiguration exportImportConfiguration) { 061 getPersistence().clearCache(exportImportConfiguration); 062 } 063 064 /** 065 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 066 */ 067 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 068 return getPersistence().countWithDynamicQuery(dynamicQuery); 069 } 070 071 /** 072 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 073 */ 074 public static List<ExportImportConfiguration> findWithDynamicQuery( 075 DynamicQuery dynamicQuery) { 076 return getPersistence().findWithDynamicQuery(dynamicQuery); 077 } 078 079 /** 080 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 081 */ 082 public static List<ExportImportConfiguration> findWithDynamicQuery( 083 DynamicQuery dynamicQuery, int start, int end) { 084 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 085 } 086 087 /** 088 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 089 */ 090 public static List<ExportImportConfiguration> findWithDynamicQuery( 091 DynamicQuery dynamicQuery, int start, int end, 092 OrderByComparator<ExportImportConfiguration> orderByComparator) { 093 return getPersistence() 094 .findWithDynamicQuery(dynamicQuery, start, end, 095 orderByComparator); 096 } 097 098 /** 099 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 100 */ 101 public static ExportImportConfiguration update( 102 ExportImportConfiguration exportImportConfiguration) { 103 return getPersistence().update(exportImportConfiguration); 104 } 105 106 /** 107 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 108 */ 109 public static ExportImportConfiguration update( 110 ExportImportConfiguration exportImportConfiguration, 111 ServiceContext serviceContext) { 112 return getPersistence().update(exportImportConfiguration, serviceContext); 113 } 114 115 /** 116 * Returns all the export import configurations where groupId = ?. 117 * 118 * @param groupId the group ID 119 * @return the matching export import configurations 120 */ 121 public static List<ExportImportConfiguration> findByGroupId(long groupId) { 122 return getPersistence().findByGroupId(groupId); 123 } 124 125 /** 126 * Returns a range of all the export import configurations where groupId = ?. 127 * 128 * <p> 129 * 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 ExportImportConfigurationModelImpl}. 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. 130 * </p> 131 * 132 * @param groupId the group ID 133 * @param start the lower bound of the range of export import configurations 134 * @param end the upper bound of the range of export import configurations (not inclusive) 135 * @return the range of matching export import configurations 136 */ 137 public static List<ExportImportConfiguration> findByGroupId(long groupId, 138 int start, int end) { 139 return getPersistence().findByGroupId(groupId, start, end); 140 } 141 142 /** 143 * Returns an ordered range of all the export import configurations where groupId = ?. 144 * 145 * <p> 146 * 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 ExportImportConfigurationModelImpl}. 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. 147 * </p> 148 * 149 * @param groupId the group ID 150 * @param start the lower bound of the range of export import configurations 151 * @param end the upper bound of the range of export import configurations (not inclusive) 152 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 153 * @return the ordered range of matching export import configurations 154 */ 155 public static List<ExportImportConfiguration> findByGroupId(long groupId, 156 int start, int end, 157 OrderByComparator<ExportImportConfiguration> orderByComparator) { 158 return getPersistence() 159 .findByGroupId(groupId, start, end, orderByComparator); 160 } 161 162 /** 163 * Returns an ordered range of all the export import configurations where groupId = ?. 164 * 165 * <p> 166 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ExportImportConfigurationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 167 * </p> 168 * 169 * @param groupId the group ID 170 * @param start the lower bound of the range of export import configurations 171 * @param end the upper bound of the range of export import configurations (not inclusive) 172 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 173 * @param retrieveFromCache whether to retrieve from the finder cache 174 * @return the ordered range of matching export import configurations 175 */ 176 public static List<ExportImportConfiguration> findByGroupId(long groupId, 177 int start, int end, 178 OrderByComparator<ExportImportConfiguration> orderByComparator, 179 boolean retrieveFromCache) { 180 return getPersistence() 181 .findByGroupId(groupId, start, end, orderByComparator, 182 retrieveFromCache); 183 } 184 185 /** 186 * Returns the first export import configuration in the ordered set where groupId = ?. 187 * 188 * @param groupId the group ID 189 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 190 * @return the first matching export import configuration 191 * @throws NoSuchConfigurationException if a matching export import configuration could not be found 192 */ 193 public static ExportImportConfiguration findByGroupId_First(long groupId, 194 OrderByComparator<ExportImportConfiguration> orderByComparator) 195 throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException { 196 return getPersistence().findByGroupId_First(groupId, orderByComparator); 197 } 198 199 /** 200 * Returns the first export import configuration in the ordered set where groupId = ?. 201 * 202 * @param groupId the group ID 203 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 204 * @return the first matching export import configuration, or <code>null</code> if a matching export import configuration could not be found 205 */ 206 public static ExportImportConfiguration fetchByGroupId_First(long groupId, 207 OrderByComparator<ExportImportConfiguration> orderByComparator) { 208 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 209 } 210 211 /** 212 * Returns the last export import configuration in the ordered set where groupId = ?. 213 * 214 * @param groupId the group ID 215 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 216 * @return the last matching export import configuration 217 * @throws NoSuchConfigurationException if a matching export import configuration could not be found 218 */ 219 public static ExportImportConfiguration findByGroupId_Last(long groupId, 220 OrderByComparator<ExportImportConfiguration> orderByComparator) 221 throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException { 222 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 223 } 224 225 /** 226 * Returns the last export import configuration in the ordered set where groupId = ?. 227 * 228 * @param groupId the group ID 229 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 230 * @return the last matching export import configuration, or <code>null</code> if a matching export import configuration could not be found 231 */ 232 public static ExportImportConfiguration fetchByGroupId_Last(long groupId, 233 OrderByComparator<ExportImportConfiguration> orderByComparator) { 234 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 235 } 236 237 /** 238 * Returns the export import configurations before and after the current export import configuration in the ordered set where groupId = ?. 239 * 240 * @param exportImportConfigurationId the primary key of the current export import configuration 241 * @param groupId the group ID 242 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 243 * @return the previous, current, and next export import configuration 244 * @throws NoSuchConfigurationException if a export import configuration with the primary key could not be found 245 */ 246 public static ExportImportConfiguration[] findByGroupId_PrevAndNext( 247 long exportImportConfigurationId, long groupId, 248 OrderByComparator<ExportImportConfiguration> orderByComparator) 249 throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException { 250 return getPersistence() 251 .findByGroupId_PrevAndNext(exportImportConfigurationId, 252 groupId, orderByComparator); 253 } 254 255 /** 256 * Removes all the export import configurations where groupId = ? from the database. 257 * 258 * @param groupId the group ID 259 */ 260 public static void removeByGroupId(long groupId) { 261 getPersistence().removeByGroupId(groupId); 262 } 263 264 /** 265 * Returns the number of export import configurations where groupId = ?. 266 * 267 * @param groupId the group ID 268 * @return the number of matching export import configurations 269 */ 270 public static int countByGroupId(long groupId) { 271 return getPersistence().countByGroupId(groupId); 272 } 273 274 /** 275 * Returns all the export import configurations where companyId = ?. 276 * 277 * @param companyId the company ID 278 * @return the matching export import configurations 279 */ 280 public static List<ExportImportConfiguration> findByCompanyId( 281 long companyId) { 282 return getPersistence().findByCompanyId(companyId); 283 } 284 285 /** 286 * Returns a range of all the export import configurations where companyId = ?. 287 * 288 * <p> 289 * 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 ExportImportConfigurationModelImpl}. 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. 290 * </p> 291 * 292 * @param companyId the company ID 293 * @param start the lower bound of the range of export import configurations 294 * @param end the upper bound of the range of export import configurations (not inclusive) 295 * @return the range of matching export import configurations 296 */ 297 public static List<ExportImportConfiguration> findByCompanyId( 298 long companyId, int start, int end) { 299 return getPersistence().findByCompanyId(companyId, start, end); 300 } 301 302 /** 303 * Returns an ordered range of all the export import configurations where companyId = ?. 304 * 305 * <p> 306 * 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 ExportImportConfigurationModelImpl}. 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. 307 * </p> 308 * 309 * @param companyId the company ID 310 * @param start the lower bound of the range of export import configurations 311 * @param end the upper bound of the range of export import configurations (not inclusive) 312 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 313 * @return the ordered range of matching export import configurations 314 */ 315 public static List<ExportImportConfiguration> findByCompanyId( 316 long companyId, int start, int end, 317 OrderByComparator<ExportImportConfiguration> orderByComparator) { 318 return getPersistence() 319 .findByCompanyId(companyId, start, end, orderByComparator); 320 } 321 322 /** 323 * Returns an ordered range of all the export import configurations where companyId = ?. 324 * 325 * <p> 326 * 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 ExportImportConfigurationModelImpl}. 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. 327 * </p> 328 * 329 * @param companyId the company ID 330 * @param start the lower bound of the range of export import configurations 331 * @param end the upper bound of the range of export import configurations (not inclusive) 332 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 333 * @param retrieveFromCache whether to retrieve from the finder cache 334 * @return the ordered range of matching export import configurations 335 */ 336 public static List<ExportImportConfiguration> findByCompanyId( 337 long companyId, int start, int end, 338 OrderByComparator<ExportImportConfiguration> orderByComparator, 339 boolean retrieveFromCache) { 340 return getPersistence() 341 .findByCompanyId(companyId, start, end, orderByComparator, 342 retrieveFromCache); 343 } 344 345 /** 346 * Returns the first export import configuration in the ordered set where companyId = ?. 347 * 348 * @param companyId the company ID 349 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 350 * @return the first matching export import configuration 351 * @throws NoSuchConfigurationException if a matching export import configuration could not be found 352 */ 353 public static ExportImportConfiguration findByCompanyId_First( 354 long companyId, 355 OrderByComparator<ExportImportConfiguration> orderByComparator) 356 throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException { 357 return getPersistence() 358 .findByCompanyId_First(companyId, orderByComparator); 359 } 360 361 /** 362 * Returns the first export import configuration in the ordered set where companyId = ?. 363 * 364 * @param companyId the company ID 365 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 366 * @return the first matching export import configuration, or <code>null</code> if a matching export import configuration could not be found 367 */ 368 public static ExportImportConfiguration fetchByCompanyId_First( 369 long companyId, 370 OrderByComparator<ExportImportConfiguration> orderByComparator) { 371 return getPersistence() 372 .fetchByCompanyId_First(companyId, orderByComparator); 373 } 374 375 /** 376 * Returns the last export import configuration in the ordered set where companyId = ?. 377 * 378 * @param companyId the company ID 379 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 380 * @return the last matching export import configuration 381 * @throws NoSuchConfigurationException if a matching export import configuration could not be found 382 */ 383 public static ExportImportConfiguration findByCompanyId_Last( 384 long companyId, 385 OrderByComparator<ExportImportConfiguration> orderByComparator) 386 throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException { 387 return getPersistence() 388 .findByCompanyId_Last(companyId, orderByComparator); 389 } 390 391 /** 392 * Returns the last export import configuration in the ordered set where companyId = ?. 393 * 394 * @param companyId the company ID 395 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 396 * @return the last matching export import configuration, or <code>null</code> if a matching export import configuration could not be found 397 */ 398 public static ExportImportConfiguration fetchByCompanyId_Last( 399 long companyId, 400 OrderByComparator<ExportImportConfiguration> orderByComparator) { 401 return getPersistence() 402 .fetchByCompanyId_Last(companyId, orderByComparator); 403 } 404 405 /** 406 * Returns the export import configurations before and after the current export import configuration in the ordered set where companyId = ?. 407 * 408 * @param exportImportConfigurationId the primary key of the current export import configuration 409 * @param companyId the company ID 410 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 411 * @return the previous, current, and next export import configuration 412 * @throws NoSuchConfigurationException if a export import configuration with the primary key could not be found 413 */ 414 public static ExportImportConfiguration[] findByCompanyId_PrevAndNext( 415 long exportImportConfigurationId, long companyId, 416 OrderByComparator<ExportImportConfiguration> orderByComparator) 417 throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException { 418 return getPersistence() 419 .findByCompanyId_PrevAndNext(exportImportConfigurationId, 420 companyId, orderByComparator); 421 } 422 423 /** 424 * Removes all the export import configurations where companyId = ? from the database. 425 * 426 * @param companyId the company ID 427 */ 428 public static void removeByCompanyId(long companyId) { 429 getPersistence().removeByCompanyId(companyId); 430 } 431 432 /** 433 * Returns the number of export import configurations where companyId = ?. 434 * 435 * @param companyId the company ID 436 * @return the number of matching export import configurations 437 */ 438 public static int countByCompanyId(long companyId) { 439 return getPersistence().countByCompanyId(companyId); 440 } 441 442 /** 443 * Returns all the export import configurations where groupId = ? and type = ?. 444 * 445 * @param groupId the group ID 446 * @param type the type 447 * @return the matching export import configurations 448 */ 449 public static List<ExportImportConfiguration> findByG_T(long groupId, 450 int type) { 451 return getPersistence().findByG_T(groupId, type); 452 } 453 454 /** 455 * Returns a range of all the export import configurations where groupId = ? and type = ?. 456 * 457 * <p> 458 * 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 ExportImportConfigurationModelImpl}. 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. 459 * </p> 460 * 461 * @param groupId the group ID 462 * @param type the type 463 * @param start the lower bound of the range of export import configurations 464 * @param end the upper bound of the range of export import configurations (not inclusive) 465 * @return the range of matching export import configurations 466 */ 467 public static List<ExportImportConfiguration> findByG_T(long groupId, 468 int type, int start, int end) { 469 return getPersistence().findByG_T(groupId, type, start, end); 470 } 471 472 /** 473 * Returns an ordered range of all the export import configurations where groupId = ? and type = ?. 474 * 475 * <p> 476 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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 ExportImportConfigurationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 477 * </p> 478 * 479 * @param groupId the group ID 480 * @param type the type 481 * @param start the lower bound of the range of export import configurations 482 * @param end the upper bound of the range of export import configurations (not inclusive) 483 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 484 * @return the ordered range of matching export import configurations 485 */ 486 public static List<ExportImportConfiguration> findByG_T(long groupId, 487 int type, int start, int end, 488 OrderByComparator<ExportImportConfiguration> orderByComparator) { 489 return getPersistence() 490 .findByG_T(groupId, type, start, end, orderByComparator); 491 } 492 493 /** 494 * Returns an ordered range of all the export import configurations where groupId = ? and type = ?. 495 * 496 * <p> 497 * 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 ExportImportConfigurationModelImpl}. 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. 498 * </p> 499 * 500 * @param groupId the group ID 501 * @param type the type 502 * @param start the lower bound of the range of export import configurations 503 * @param end the upper bound of the range of export import configurations (not inclusive) 504 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 505 * @param retrieveFromCache whether to retrieve from the finder cache 506 * @return the ordered range of matching export import configurations 507 */ 508 public static List<ExportImportConfiguration> findByG_T(long groupId, 509 int type, int start, int end, 510 OrderByComparator<ExportImportConfiguration> orderByComparator, 511 boolean retrieveFromCache) { 512 return getPersistence() 513 .findByG_T(groupId, type, start, end, orderByComparator, 514 retrieveFromCache); 515 } 516 517 /** 518 * Returns the first export import configuration in the ordered set where groupId = ? and type = ?. 519 * 520 * @param groupId the group ID 521 * @param type the type 522 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 523 * @return the first matching export import configuration 524 * @throws NoSuchConfigurationException if a matching export import configuration could not be found 525 */ 526 public static ExportImportConfiguration findByG_T_First(long groupId, 527 int type, OrderByComparator<ExportImportConfiguration> orderByComparator) 528 throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException { 529 return getPersistence().findByG_T_First(groupId, type, orderByComparator); 530 } 531 532 /** 533 * Returns the first export import configuration in the ordered set where groupId = ? and type = ?. 534 * 535 * @param groupId the group ID 536 * @param type the type 537 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 538 * @return the first matching export import configuration, or <code>null</code> if a matching export import configuration could not be found 539 */ 540 public static ExportImportConfiguration fetchByG_T_First(long groupId, 541 int type, OrderByComparator<ExportImportConfiguration> orderByComparator) { 542 return getPersistence() 543 .fetchByG_T_First(groupId, type, orderByComparator); 544 } 545 546 /** 547 * Returns the last export import configuration in the ordered set where groupId = ? and type = ?. 548 * 549 * @param groupId the group ID 550 * @param type the type 551 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 552 * @return the last matching export import configuration 553 * @throws NoSuchConfigurationException if a matching export import configuration could not be found 554 */ 555 public static ExportImportConfiguration findByG_T_Last(long groupId, 556 int type, OrderByComparator<ExportImportConfiguration> orderByComparator) 557 throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException { 558 return getPersistence().findByG_T_Last(groupId, type, orderByComparator); 559 } 560 561 /** 562 * Returns the last export import configuration in the ordered set where groupId = ? and type = ?. 563 * 564 * @param groupId the group ID 565 * @param type the type 566 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 567 * @return the last matching export import configuration, or <code>null</code> if a matching export import configuration could not be found 568 */ 569 public static ExportImportConfiguration fetchByG_T_Last(long groupId, 570 int type, OrderByComparator<ExportImportConfiguration> orderByComparator) { 571 return getPersistence().fetchByG_T_Last(groupId, type, orderByComparator); 572 } 573 574 /** 575 * Returns the export import configurations before and after the current export import configuration in the ordered set where groupId = ? and type = ?. 576 * 577 * @param exportImportConfigurationId the primary key of the current export import configuration 578 * @param groupId the group ID 579 * @param type the type 580 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 581 * @return the previous, current, and next export import configuration 582 * @throws NoSuchConfigurationException if a export import configuration with the primary key could not be found 583 */ 584 public static ExportImportConfiguration[] findByG_T_PrevAndNext( 585 long exportImportConfigurationId, long groupId, int type, 586 OrderByComparator<ExportImportConfiguration> orderByComparator) 587 throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException { 588 return getPersistence() 589 .findByG_T_PrevAndNext(exportImportConfigurationId, groupId, 590 type, orderByComparator); 591 } 592 593 /** 594 * Removes all the export import configurations where groupId = ? and type = ? from the database. 595 * 596 * @param groupId the group ID 597 * @param type the type 598 */ 599 public static void removeByG_T(long groupId, int type) { 600 getPersistence().removeByG_T(groupId, type); 601 } 602 603 /** 604 * Returns the number of export import configurations where groupId = ? and type = ?. 605 * 606 * @param groupId the group ID 607 * @param type the type 608 * @return the number of matching export import configurations 609 */ 610 public static int countByG_T(long groupId, int type) { 611 return getPersistence().countByG_T(groupId, type); 612 } 613 614 /** 615 * Returns all the export import configurations where groupId = ? and status = ?. 616 * 617 * @param groupId the group ID 618 * @param status the status 619 * @return the matching export import configurations 620 */ 621 public static List<ExportImportConfiguration> findByG_S(long groupId, 622 int status) { 623 return getPersistence().findByG_S(groupId, status); 624 } 625 626 /** 627 * Returns a range of all the export import configurations where groupId = ? and status = ?. 628 * 629 * <p> 630 * 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 ExportImportConfigurationModelImpl}. 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. 631 * </p> 632 * 633 * @param groupId the group ID 634 * @param status the status 635 * @param start the lower bound of the range of export import configurations 636 * @param end the upper bound of the range of export import configurations (not inclusive) 637 * @return the range of matching export import configurations 638 */ 639 public static List<ExportImportConfiguration> findByG_S(long groupId, 640 int status, int start, int end) { 641 return getPersistence().findByG_S(groupId, status, start, end); 642 } 643 644 /** 645 * Returns an ordered range of all the export import configurations where groupId = ? and status = ?. 646 * 647 * <p> 648 * 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 ExportImportConfigurationModelImpl}. 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. 649 * </p> 650 * 651 * @param groupId the group ID 652 * @param status the status 653 * @param start the lower bound of the range of export import configurations 654 * @param end the upper bound of the range of export import configurations (not inclusive) 655 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 656 * @return the ordered range of matching export import configurations 657 */ 658 public static List<ExportImportConfiguration> findByG_S(long groupId, 659 int status, int start, int end, 660 OrderByComparator<ExportImportConfiguration> orderByComparator) { 661 return getPersistence() 662 .findByG_S(groupId, status, start, end, orderByComparator); 663 } 664 665 /** 666 * Returns an ordered range of all the export import configurations where groupId = ? and status = ?. 667 * 668 * <p> 669 * 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 ExportImportConfigurationModelImpl}. 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. 670 * </p> 671 * 672 * @param groupId the group ID 673 * @param status the status 674 * @param start the lower bound of the range of export import configurations 675 * @param end the upper bound of the range of export import configurations (not inclusive) 676 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 677 * @param retrieveFromCache whether to retrieve from the finder cache 678 * @return the ordered range of matching export import configurations 679 */ 680 public static List<ExportImportConfiguration> findByG_S(long groupId, 681 int status, int start, int end, 682 OrderByComparator<ExportImportConfiguration> orderByComparator, 683 boolean retrieveFromCache) { 684 return getPersistence() 685 .findByG_S(groupId, status, start, end, orderByComparator, 686 retrieveFromCache); 687 } 688 689 /** 690 * Returns the first export import configuration in the ordered set where groupId = ? and status = ?. 691 * 692 * @param groupId the group ID 693 * @param status the status 694 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 695 * @return the first matching export import configuration 696 * @throws NoSuchConfigurationException if a matching export import configuration could not be found 697 */ 698 public static ExportImportConfiguration findByG_S_First(long groupId, 699 int status, 700 OrderByComparator<ExportImportConfiguration> orderByComparator) 701 throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException { 702 return getPersistence() 703 .findByG_S_First(groupId, status, orderByComparator); 704 } 705 706 /** 707 * Returns the first export import configuration in the ordered set where groupId = ? and status = ?. 708 * 709 * @param groupId the group ID 710 * @param status the status 711 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 712 * @return the first matching export import configuration, or <code>null</code> if a matching export import configuration could not be found 713 */ 714 public static ExportImportConfiguration fetchByG_S_First(long groupId, 715 int status, 716 OrderByComparator<ExportImportConfiguration> orderByComparator) { 717 return getPersistence() 718 .fetchByG_S_First(groupId, status, orderByComparator); 719 } 720 721 /** 722 * Returns the last export import configuration in the ordered set where groupId = ? and status = ?. 723 * 724 * @param groupId the group ID 725 * @param status the status 726 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 727 * @return the last matching export import configuration 728 * @throws NoSuchConfigurationException if a matching export import configuration could not be found 729 */ 730 public static ExportImportConfiguration findByG_S_Last(long groupId, 731 int status, 732 OrderByComparator<ExportImportConfiguration> orderByComparator) 733 throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException { 734 return getPersistence() 735 .findByG_S_Last(groupId, status, orderByComparator); 736 } 737 738 /** 739 * Returns the last export import configuration in the ordered set where groupId = ? and status = ?. 740 * 741 * @param groupId the group ID 742 * @param status the status 743 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 744 * @return the last matching export import configuration, or <code>null</code> if a matching export import configuration could not be found 745 */ 746 public static ExportImportConfiguration fetchByG_S_Last(long groupId, 747 int status, 748 OrderByComparator<ExportImportConfiguration> orderByComparator) { 749 return getPersistence() 750 .fetchByG_S_Last(groupId, status, orderByComparator); 751 } 752 753 /** 754 * Returns the export import configurations before and after the current export import configuration in the ordered set where groupId = ? and status = ?. 755 * 756 * @param exportImportConfigurationId the primary key of the current export import configuration 757 * @param groupId the group ID 758 * @param status the status 759 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 760 * @return the previous, current, and next export import configuration 761 * @throws NoSuchConfigurationException if a export import configuration with the primary key could not be found 762 */ 763 public static ExportImportConfiguration[] findByG_S_PrevAndNext( 764 long exportImportConfigurationId, long groupId, int status, 765 OrderByComparator<ExportImportConfiguration> orderByComparator) 766 throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException { 767 return getPersistence() 768 .findByG_S_PrevAndNext(exportImportConfigurationId, groupId, 769 status, orderByComparator); 770 } 771 772 /** 773 * Removes all the export import configurations where groupId = ? and status = ? from the database. 774 * 775 * @param groupId the group ID 776 * @param status the status 777 */ 778 public static void removeByG_S(long groupId, int status) { 779 getPersistence().removeByG_S(groupId, status); 780 } 781 782 /** 783 * Returns the number of export import configurations where groupId = ? and status = ?. 784 * 785 * @param groupId the group ID 786 * @param status the status 787 * @return the number of matching export import configurations 788 */ 789 public static int countByG_S(long groupId, int status) { 790 return getPersistence().countByG_S(groupId, status); 791 } 792 793 /** 794 * Returns all the export import configurations where groupId = ? and type = ? and status = ?. 795 * 796 * @param groupId the group ID 797 * @param type the type 798 * @param status the status 799 * @return the matching export import configurations 800 */ 801 public static List<ExportImportConfiguration> findByG_T_S(long groupId, 802 int type, int status) { 803 return getPersistence().findByG_T_S(groupId, type, status); 804 } 805 806 /** 807 * Returns a range of all the export import configurations where groupId = ? and type = ? and status = ?. 808 * 809 * <p> 810 * 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 ExportImportConfigurationModelImpl}. 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. 811 * </p> 812 * 813 * @param groupId the group ID 814 * @param type the type 815 * @param status the status 816 * @param start the lower bound of the range of export import configurations 817 * @param end the upper bound of the range of export import configurations (not inclusive) 818 * @return the range of matching export import configurations 819 */ 820 public static List<ExportImportConfiguration> findByG_T_S(long groupId, 821 int type, int status, int start, int end) { 822 return getPersistence().findByG_T_S(groupId, type, status, start, end); 823 } 824 825 /** 826 * Returns an ordered range of all the export import configurations where groupId = ? and type = ? and status = ?. 827 * 828 * <p> 829 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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 ExportImportConfigurationModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 830 * </p> 831 * 832 * @param groupId the group ID 833 * @param type the type 834 * @param status the status 835 * @param start the lower bound of the range of export import configurations 836 * @param end the upper bound of the range of export import configurations (not inclusive) 837 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 838 * @return the ordered range of matching export import configurations 839 */ 840 public static List<ExportImportConfiguration> findByG_T_S(long groupId, 841 int type, int status, int start, int end, 842 OrderByComparator<ExportImportConfiguration> orderByComparator) { 843 return getPersistence() 844 .findByG_T_S(groupId, type, status, start, end, 845 orderByComparator); 846 } 847 848 /** 849 * Returns an ordered range of all the export import configurations where groupId = ? and type = ? and status = ?. 850 * 851 * <p> 852 * 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 ExportImportConfigurationModelImpl}. 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. 853 * </p> 854 * 855 * @param groupId the group ID 856 * @param type the type 857 * @param status the status 858 * @param start the lower bound of the range of export import configurations 859 * @param end the upper bound of the range of export import configurations (not inclusive) 860 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 861 * @param retrieveFromCache whether to retrieve from the finder cache 862 * @return the ordered range of matching export import configurations 863 */ 864 public static List<ExportImportConfiguration> findByG_T_S(long groupId, 865 int type, int status, int start, int end, 866 OrderByComparator<ExportImportConfiguration> orderByComparator, 867 boolean retrieveFromCache) { 868 return getPersistence() 869 .findByG_T_S(groupId, type, status, start, end, 870 orderByComparator, retrieveFromCache); 871 } 872 873 /** 874 * Returns the first export import configuration in the ordered set where groupId = ? and type = ? and status = ?. 875 * 876 * @param groupId the group ID 877 * @param type the type 878 * @param status the status 879 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 880 * @return the first matching export import configuration 881 * @throws NoSuchConfigurationException if a matching export import configuration could not be found 882 */ 883 public static ExportImportConfiguration findByG_T_S_First(long groupId, 884 int type, int status, 885 OrderByComparator<ExportImportConfiguration> orderByComparator) 886 throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException { 887 return getPersistence() 888 .findByG_T_S_First(groupId, type, status, orderByComparator); 889 } 890 891 /** 892 * Returns the first export import configuration in the ordered set where groupId = ? and type = ? and status = ?. 893 * 894 * @param groupId the group ID 895 * @param type the type 896 * @param status the status 897 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 898 * @return the first matching export import configuration, or <code>null</code> if a matching export import configuration could not be found 899 */ 900 public static ExportImportConfiguration fetchByG_T_S_First(long groupId, 901 int type, int status, 902 OrderByComparator<ExportImportConfiguration> orderByComparator) { 903 return getPersistence() 904 .fetchByG_T_S_First(groupId, type, status, orderByComparator); 905 } 906 907 /** 908 * Returns the last export import configuration in the ordered set where groupId = ? and type = ? and status = ?. 909 * 910 * @param groupId the group ID 911 * @param type the type 912 * @param status the status 913 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 914 * @return the last matching export import configuration 915 * @throws NoSuchConfigurationException if a matching export import configuration could not be found 916 */ 917 public static ExportImportConfiguration findByG_T_S_Last(long groupId, 918 int type, int status, 919 OrderByComparator<ExportImportConfiguration> orderByComparator) 920 throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException { 921 return getPersistence() 922 .findByG_T_S_Last(groupId, type, status, orderByComparator); 923 } 924 925 /** 926 * Returns the last export import configuration in the ordered set where groupId = ? and type = ? and status = ?. 927 * 928 * @param groupId the group ID 929 * @param type the type 930 * @param status the status 931 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 932 * @return the last matching export import configuration, or <code>null</code> if a matching export import configuration could not be found 933 */ 934 public static ExportImportConfiguration fetchByG_T_S_Last(long groupId, 935 int type, int status, 936 OrderByComparator<ExportImportConfiguration> orderByComparator) { 937 return getPersistence() 938 .fetchByG_T_S_Last(groupId, type, status, orderByComparator); 939 } 940 941 /** 942 * Returns the export import configurations before and after the current export import configuration in the ordered set where groupId = ? and type = ? and status = ?. 943 * 944 * @param exportImportConfigurationId the primary key of the current export import configuration 945 * @param groupId the group ID 946 * @param type the type 947 * @param status the status 948 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 949 * @return the previous, current, and next export import configuration 950 * @throws NoSuchConfigurationException if a export import configuration with the primary key could not be found 951 */ 952 public static ExportImportConfiguration[] findByG_T_S_PrevAndNext( 953 long exportImportConfigurationId, long groupId, int type, int status, 954 OrderByComparator<ExportImportConfiguration> orderByComparator) 955 throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException { 956 return getPersistence() 957 .findByG_T_S_PrevAndNext(exportImportConfigurationId, 958 groupId, type, status, orderByComparator); 959 } 960 961 /** 962 * Removes all the export import configurations where groupId = ? and type = ? and status = ? from the database. 963 * 964 * @param groupId the group ID 965 * @param type the type 966 * @param status the status 967 */ 968 public static void removeByG_T_S(long groupId, int type, int status) { 969 getPersistence().removeByG_T_S(groupId, type, status); 970 } 971 972 /** 973 * Returns the number of export import configurations where groupId = ? and type = ? and status = ?. 974 * 975 * @param groupId the group ID 976 * @param type the type 977 * @param status the status 978 * @return the number of matching export import configurations 979 */ 980 public static int countByG_T_S(long groupId, int type, int status) { 981 return getPersistence().countByG_T_S(groupId, type, status); 982 } 983 984 /** 985 * Caches the export import configuration in the entity cache if it is enabled. 986 * 987 * @param exportImportConfiguration the export import configuration 988 */ 989 public static void cacheResult( 990 ExportImportConfiguration exportImportConfiguration) { 991 getPersistence().cacheResult(exportImportConfiguration); 992 } 993 994 /** 995 * Caches the export import configurations in the entity cache if it is enabled. 996 * 997 * @param exportImportConfigurations the export import configurations 998 */ 999 public static void cacheResult( 1000 List<ExportImportConfiguration> exportImportConfigurations) { 1001 getPersistence().cacheResult(exportImportConfigurations); 1002 } 1003 1004 /** 1005 * Creates a new export import configuration with the primary key. Does not add the export import configuration to the database. 1006 * 1007 * @param exportImportConfigurationId the primary key for the new export import configuration 1008 * @return the new export import configuration 1009 */ 1010 public static ExportImportConfiguration create( 1011 long exportImportConfigurationId) { 1012 return getPersistence().create(exportImportConfigurationId); 1013 } 1014 1015 /** 1016 * Removes the export import configuration with the primary key from the database. Also notifies the appropriate model listeners. 1017 * 1018 * @param exportImportConfigurationId the primary key of the export import configuration 1019 * @return the export import configuration that was removed 1020 * @throws NoSuchConfigurationException if a export import configuration with the primary key could not be found 1021 */ 1022 public static ExportImportConfiguration remove( 1023 long exportImportConfigurationId) 1024 throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException { 1025 return getPersistence().remove(exportImportConfigurationId); 1026 } 1027 1028 public static ExportImportConfiguration updateImpl( 1029 ExportImportConfiguration exportImportConfiguration) { 1030 return getPersistence().updateImpl(exportImportConfiguration); 1031 } 1032 1033 /** 1034 * Returns the export import configuration with the primary key or throws a {@link NoSuchConfigurationException} if it could not be found. 1035 * 1036 * @param exportImportConfigurationId the primary key of the export import configuration 1037 * @return the export import configuration 1038 * @throws NoSuchConfigurationException if a export import configuration with the primary key could not be found 1039 */ 1040 public static ExportImportConfiguration findByPrimaryKey( 1041 long exportImportConfigurationId) 1042 throws com.liferay.portlet.exportimport.exception.NoSuchConfigurationException { 1043 return getPersistence().findByPrimaryKey(exportImportConfigurationId); 1044 } 1045 1046 /** 1047 * Returns the export import configuration with the primary key or returns <code>null</code> if it could not be found. 1048 * 1049 * @param exportImportConfigurationId the primary key of the export import configuration 1050 * @return the export import configuration, or <code>null</code> if a export import configuration with the primary key could not be found 1051 */ 1052 public static ExportImportConfiguration fetchByPrimaryKey( 1053 long exportImportConfigurationId) { 1054 return getPersistence().fetchByPrimaryKey(exportImportConfigurationId); 1055 } 1056 1057 public static java.util.Map<java.io.Serializable, ExportImportConfiguration> fetchByPrimaryKeys( 1058 java.util.Set<java.io.Serializable> primaryKeys) { 1059 return getPersistence().fetchByPrimaryKeys(primaryKeys); 1060 } 1061 1062 /** 1063 * Returns all the export import configurations. 1064 * 1065 * @return the export import configurations 1066 */ 1067 public static List<ExportImportConfiguration> findAll() { 1068 return getPersistence().findAll(); 1069 } 1070 1071 /** 1072 * Returns a range of all the export import configurations. 1073 * 1074 * <p> 1075 * 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 ExportImportConfigurationModelImpl}. 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. 1076 * </p> 1077 * 1078 * @param start the lower bound of the range of export import configurations 1079 * @param end the upper bound of the range of export import configurations (not inclusive) 1080 * @return the range of export import configurations 1081 */ 1082 public static List<ExportImportConfiguration> findAll(int start, int end) { 1083 return getPersistence().findAll(start, end); 1084 } 1085 1086 /** 1087 * Returns an ordered range of all the export import configurations. 1088 * 1089 * <p> 1090 * 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 ExportImportConfigurationModelImpl}. 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. 1091 * </p> 1092 * 1093 * @param start the lower bound of the range of export import configurations 1094 * @param end the upper bound of the range of export import configurations (not inclusive) 1095 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1096 * @return the ordered range of export import configurations 1097 */ 1098 public static List<ExportImportConfiguration> findAll(int start, int end, 1099 OrderByComparator<ExportImportConfiguration> orderByComparator) { 1100 return getPersistence().findAll(start, end, orderByComparator); 1101 } 1102 1103 /** 1104 * Returns an ordered range of all the export import configurations. 1105 * 1106 * <p> 1107 * 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 ExportImportConfigurationModelImpl}. 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. 1108 * </p> 1109 * 1110 * @param start the lower bound of the range of export import configurations 1111 * @param end the upper bound of the range of export import configurations (not inclusive) 1112 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1113 * @param retrieveFromCache whether to retrieve from the finder cache 1114 * @return the ordered range of export import configurations 1115 */ 1116 public static List<ExportImportConfiguration> findAll(int start, int end, 1117 OrderByComparator<ExportImportConfiguration> orderByComparator, 1118 boolean retrieveFromCache) { 1119 return getPersistence() 1120 .findAll(start, end, orderByComparator, retrieveFromCache); 1121 } 1122 1123 /** 1124 * Removes all the export import configurations from the database. 1125 */ 1126 public static void removeAll() { 1127 getPersistence().removeAll(); 1128 } 1129 1130 /** 1131 * Returns the number of export import configurations. 1132 * 1133 * @return the number of export import configurations 1134 */ 1135 public static int countAll() { 1136 return getPersistence().countAll(); 1137 } 1138 1139 public static java.util.Set<java.lang.String> getBadColumnNames() { 1140 return getPersistence().getBadColumnNames(); 1141 } 1142 1143 public static ExportImportConfigurationPersistence getPersistence() { 1144 if (_persistence == null) { 1145 _persistence = (ExportImportConfigurationPersistence)PortalBeanLocatorUtil.locate(ExportImportConfigurationPersistence.class.getName()); 1146 1147 ReferenceRegistry.registerReference(ExportImportConfigurationUtil.class, 1148 "_persistence"); 1149 } 1150 1151 return _persistence; 1152 } 1153 1154 private static ExportImportConfigurationPersistence _persistence; 1155 }