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.asset.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.asset.model.AssetCategoryProperty; 026 027 import java.util.List; 028 029 /** 030 * The persistence utility for the asset category property service. This utility wraps {@link com.liferay.portlet.asset.service.persistence.impl.AssetCategoryPropertyPersistenceImpl} 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 AssetCategoryPropertyPersistence 038 * @see com.liferay.portlet.asset.service.persistence.impl.AssetCategoryPropertyPersistenceImpl 039 * @generated 040 */ 041 @ProviderType 042 public class AssetCategoryPropertyUtil { 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(AssetCategoryProperty assetCategoryProperty) { 060 getPersistence().clearCache(assetCategoryProperty); 061 } 062 063 /** 064 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 065 */ 066 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 067 return getPersistence().countWithDynamicQuery(dynamicQuery); 068 } 069 070 /** 071 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 072 */ 073 public static List<AssetCategoryProperty> findWithDynamicQuery( 074 DynamicQuery dynamicQuery) { 075 return getPersistence().findWithDynamicQuery(dynamicQuery); 076 } 077 078 /** 079 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 080 */ 081 public static List<AssetCategoryProperty> findWithDynamicQuery( 082 DynamicQuery dynamicQuery, int start, int end) { 083 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 084 } 085 086 /** 087 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 088 */ 089 public static List<AssetCategoryProperty> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator<AssetCategoryProperty> orderByComparator) { 092 return getPersistence() 093 .findWithDynamicQuery(dynamicQuery, start, end, 094 orderByComparator); 095 } 096 097 /** 098 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 099 */ 100 public static AssetCategoryProperty update( 101 AssetCategoryProperty assetCategoryProperty) { 102 return getPersistence().update(assetCategoryProperty); 103 } 104 105 /** 106 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 107 */ 108 public static AssetCategoryProperty update( 109 AssetCategoryProperty assetCategoryProperty, 110 ServiceContext serviceContext) { 111 return getPersistence().update(assetCategoryProperty, serviceContext); 112 } 113 114 /** 115 * Returns all the asset category properties where companyId = ?. 116 * 117 * @param companyId the company ID 118 * @return the matching asset category properties 119 */ 120 public static List<AssetCategoryProperty> findByCompanyId(long companyId) { 121 return getPersistence().findByCompanyId(companyId); 122 } 123 124 /** 125 * Returns a range of all the asset category properties where companyId = ?. 126 * 127 * <p> 128 * 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 AssetCategoryPropertyModelImpl}. 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. 129 * </p> 130 * 131 * @param companyId the company ID 132 * @param start the lower bound of the range of asset category properties 133 * @param end the upper bound of the range of asset category properties (not inclusive) 134 * @return the range of matching asset category properties 135 */ 136 public static List<AssetCategoryProperty> findByCompanyId(long companyId, 137 int start, int end) { 138 return getPersistence().findByCompanyId(companyId, start, end); 139 } 140 141 /** 142 * Returns an ordered range of all the asset category properties where companyId = ?. 143 * 144 * <p> 145 * 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 AssetCategoryPropertyModelImpl}. 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. 146 * </p> 147 * 148 * @param companyId the company ID 149 * @param start the lower bound of the range of asset category properties 150 * @param end the upper bound of the range of asset category properties (not inclusive) 151 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 152 * @return the ordered range of matching asset category properties 153 */ 154 public static List<AssetCategoryProperty> findByCompanyId(long companyId, 155 int start, int end, 156 OrderByComparator<AssetCategoryProperty> orderByComparator) { 157 return getPersistence() 158 .findByCompanyId(companyId, start, end, orderByComparator); 159 } 160 161 /** 162 * Returns an ordered range of all the asset category properties where companyId = ?. 163 * 164 * <p> 165 * 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 AssetCategoryPropertyModelImpl}. 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. 166 * </p> 167 * 168 * @param companyId the company ID 169 * @param start the lower bound of the range of asset category properties 170 * @param end the upper bound of the range of asset category properties (not inclusive) 171 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 172 * @param retrieveFromCache whether to retrieve from the finder cache 173 * @return the ordered range of matching asset category properties 174 */ 175 public static List<AssetCategoryProperty> findByCompanyId(long companyId, 176 int start, int end, 177 OrderByComparator<AssetCategoryProperty> orderByComparator, 178 boolean retrieveFromCache) { 179 return getPersistence() 180 .findByCompanyId(companyId, start, end, orderByComparator, 181 retrieveFromCache); 182 } 183 184 /** 185 * Returns the first asset category property in the ordered set where companyId = ?. 186 * 187 * @param companyId the company ID 188 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 189 * @return the first matching asset category property 190 * @throws NoSuchCategoryPropertyException if a matching asset category property could not be found 191 */ 192 public static AssetCategoryProperty findByCompanyId_First(long companyId, 193 OrderByComparator<AssetCategoryProperty> orderByComparator) 194 throws com.liferay.portlet.asset.exception.NoSuchCategoryPropertyException { 195 return getPersistence() 196 .findByCompanyId_First(companyId, orderByComparator); 197 } 198 199 /** 200 * Returns the first asset category property in the ordered set where companyId = ?. 201 * 202 * @param companyId the company ID 203 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 204 * @return the first matching asset category property, or <code>null</code> if a matching asset category property could not be found 205 */ 206 public static AssetCategoryProperty fetchByCompanyId_First(long companyId, 207 OrderByComparator<AssetCategoryProperty> orderByComparator) { 208 return getPersistence() 209 .fetchByCompanyId_First(companyId, orderByComparator); 210 } 211 212 /** 213 * Returns the last asset category property in the ordered set where companyId = ?. 214 * 215 * @param companyId the company ID 216 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 217 * @return the last matching asset category property 218 * @throws NoSuchCategoryPropertyException if a matching asset category property could not be found 219 */ 220 public static AssetCategoryProperty findByCompanyId_Last(long companyId, 221 OrderByComparator<AssetCategoryProperty> orderByComparator) 222 throws com.liferay.portlet.asset.exception.NoSuchCategoryPropertyException { 223 return getPersistence() 224 .findByCompanyId_Last(companyId, orderByComparator); 225 } 226 227 /** 228 * Returns the last asset category property in the ordered set where companyId = ?. 229 * 230 * @param companyId the company ID 231 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 232 * @return the last matching asset category property, or <code>null</code> if a matching asset category property could not be found 233 */ 234 public static AssetCategoryProperty fetchByCompanyId_Last(long companyId, 235 OrderByComparator<AssetCategoryProperty> orderByComparator) { 236 return getPersistence() 237 .fetchByCompanyId_Last(companyId, orderByComparator); 238 } 239 240 /** 241 * Returns the asset category properties before and after the current asset category property in the ordered set where companyId = ?. 242 * 243 * @param categoryPropertyId the primary key of the current asset category property 244 * @param companyId the company ID 245 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 246 * @return the previous, current, and next asset category property 247 * @throws NoSuchCategoryPropertyException if a asset category property with the primary key could not be found 248 */ 249 public static AssetCategoryProperty[] findByCompanyId_PrevAndNext( 250 long categoryPropertyId, long companyId, 251 OrderByComparator<AssetCategoryProperty> orderByComparator) 252 throws com.liferay.portlet.asset.exception.NoSuchCategoryPropertyException { 253 return getPersistence() 254 .findByCompanyId_PrevAndNext(categoryPropertyId, companyId, 255 orderByComparator); 256 } 257 258 /** 259 * Removes all the asset category properties where companyId = ? from the database. 260 * 261 * @param companyId the company ID 262 */ 263 public static void removeByCompanyId(long companyId) { 264 getPersistence().removeByCompanyId(companyId); 265 } 266 267 /** 268 * Returns the number of asset category properties where companyId = ?. 269 * 270 * @param companyId the company ID 271 * @return the number of matching asset category properties 272 */ 273 public static int countByCompanyId(long companyId) { 274 return getPersistence().countByCompanyId(companyId); 275 } 276 277 /** 278 * Returns all the asset category properties where categoryId = ?. 279 * 280 * @param categoryId the category ID 281 * @return the matching asset category properties 282 */ 283 public static List<AssetCategoryProperty> findByCategoryId(long categoryId) { 284 return getPersistence().findByCategoryId(categoryId); 285 } 286 287 /** 288 * Returns a range of all the asset category properties where categoryId = ?. 289 * 290 * <p> 291 * 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 AssetCategoryPropertyModelImpl}. 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. 292 * </p> 293 * 294 * @param categoryId the category ID 295 * @param start the lower bound of the range of asset category properties 296 * @param end the upper bound of the range of asset category properties (not inclusive) 297 * @return the range of matching asset category properties 298 */ 299 public static List<AssetCategoryProperty> findByCategoryId( 300 long categoryId, int start, int end) { 301 return getPersistence().findByCategoryId(categoryId, start, end); 302 } 303 304 /** 305 * Returns an ordered range of all the asset category properties where categoryId = ?. 306 * 307 * <p> 308 * 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 AssetCategoryPropertyModelImpl}. 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. 309 * </p> 310 * 311 * @param categoryId the category ID 312 * @param start the lower bound of the range of asset category properties 313 * @param end the upper bound of the range of asset category properties (not inclusive) 314 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 315 * @return the ordered range of matching asset category properties 316 */ 317 public static List<AssetCategoryProperty> findByCategoryId( 318 long categoryId, int start, int end, 319 OrderByComparator<AssetCategoryProperty> orderByComparator) { 320 return getPersistence() 321 .findByCategoryId(categoryId, start, end, orderByComparator); 322 } 323 324 /** 325 * Returns an ordered range of all the asset category properties where categoryId = ?. 326 * 327 * <p> 328 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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 AssetCategoryPropertyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 329 * </p> 330 * 331 * @param categoryId the category ID 332 * @param start the lower bound of the range of asset category properties 333 * @param end the upper bound of the range of asset category properties (not inclusive) 334 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 335 * @param retrieveFromCache whether to retrieve from the finder cache 336 * @return the ordered range of matching asset category properties 337 */ 338 public static List<AssetCategoryProperty> findByCategoryId( 339 long categoryId, int start, int end, 340 OrderByComparator<AssetCategoryProperty> orderByComparator, 341 boolean retrieveFromCache) { 342 return getPersistence() 343 .findByCategoryId(categoryId, start, end, orderByComparator, 344 retrieveFromCache); 345 } 346 347 /** 348 * Returns the first asset category property in the ordered set where categoryId = ?. 349 * 350 * @param categoryId the category ID 351 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 352 * @return the first matching asset category property 353 * @throws NoSuchCategoryPropertyException if a matching asset category property could not be found 354 */ 355 public static AssetCategoryProperty findByCategoryId_First( 356 long categoryId, 357 OrderByComparator<AssetCategoryProperty> orderByComparator) 358 throws com.liferay.portlet.asset.exception.NoSuchCategoryPropertyException { 359 return getPersistence() 360 .findByCategoryId_First(categoryId, orderByComparator); 361 } 362 363 /** 364 * Returns the first asset category property in the ordered set where categoryId = ?. 365 * 366 * @param categoryId the category ID 367 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 368 * @return the first matching asset category property, or <code>null</code> if a matching asset category property could not be found 369 */ 370 public static AssetCategoryProperty fetchByCategoryId_First( 371 long categoryId, 372 OrderByComparator<AssetCategoryProperty> orderByComparator) { 373 return getPersistence() 374 .fetchByCategoryId_First(categoryId, orderByComparator); 375 } 376 377 /** 378 * Returns the last asset category property in the ordered set where categoryId = ?. 379 * 380 * @param categoryId the category ID 381 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 382 * @return the last matching asset category property 383 * @throws NoSuchCategoryPropertyException if a matching asset category property could not be found 384 */ 385 public static AssetCategoryProperty findByCategoryId_Last(long categoryId, 386 OrderByComparator<AssetCategoryProperty> orderByComparator) 387 throws com.liferay.portlet.asset.exception.NoSuchCategoryPropertyException { 388 return getPersistence() 389 .findByCategoryId_Last(categoryId, orderByComparator); 390 } 391 392 /** 393 * Returns the last asset category property in the ordered set where categoryId = ?. 394 * 395 * @param categoryId the category ID 396 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 397 * @return the last matching asset category property, or <code>null</code> if a matching asset category property could not be found 398 */ 399 public static AssetCategoryProperty fetchByCategoryId_Last( 400 long categoryId, 401 OrderByComparator<AssetCategoryProperty> orderByComparator) { 402 return getPersistence() 403 .fetchByCategoryId_Last(categoryId, orderByComparator); 404 } 405 406 /** 407 * Returns the asset category properties before and after the current asset category property in the ordered set where categoryId = ?. 408 * 409 * @param categoryPropertyId the primary key of the current asset category property 410 * @param categoryId the category ID 411 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 412 * @return the previous, current, and next asset category property 413 * @throws NoSuchCategoryPropertyException if a asset category property with the primary key could not be found 414 */ 415 public static AssetCategoryProperty[] findByCategoryId_PrevAndNext( 416 long categoryPropertyId, long categoryId, 417 OrderByComparator<AssetCategoryProperty> orderByComparator) 418 throws com.liferay.portlet.asset.exception.NoSuchCategoryPropertyException { 419 return getPersistence() 420 .findByCategoryId_PrevAndNext(categoryPropertyId, 421 categoryId, orderByComparator); 422 } 423 424 /** 425 * Removes all the asset category properties where categoryId = ? from the database. 426 * 427 * @param categoryId the category ID 428 */ 429 public static void removeByCategoryId(long categoryId) { 430 getPersistence().removeByCategoryId(categoryId); 431 } 432 433 /** 434 * Returns the number of asset category properties where categoryId = ?. 435 * 436 * @param categoryId the category ID 437 * @return the number of matching asset category properties 438 */ 439 public static int countByCategoryId(long categoryId) { 440 return getPersistence().countByCategoryId(categoryId); 441 } 442 443 /** 444 * Returns all the asset category properties where companyId = ? and key = ?. 445 * 446 * @param companyId the company ID 447 * @param key the key 448 * @return the matching asset category properties 449 */ 450 public static List<AssetCategoryProperty> findByC_K(long companyId, 451 java.lang.String key) { 452 return getPersistence().findByC_K(companyId, key); 453 } 454 455 /** 456 * Returns a range of all the asset category properties where companyId = ? and key = ?. 457 * 458 * <p> 459 * 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 AssetCategoryPropertyModelImpl}. 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. 460 * </p> 461 * 462 * @param companyId the company ID 463 * @param key the key 464 * @param start the lower bound of the range of asset category properties 465 * @param end the upper bound of the range of asset category properties (not inclusive) 466 * @return the range of matching asset category properties 467 */ 468 public static List<AssetCategoryProperty> findByC_K(long companyId, 469 java.lang.String key, int start, int end) { 470 return getPersistence().findByC_K(companyId, key, start, end); 471 } 472 473 /** 474 * Returns an ordered range of all the asset category properties where companyId = ? and key = ?. 475 * 476 * <p> 477 * 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 AssetCategoryPropertyModelImpl}. 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. 478 * </p> 479 * 480 * @param companyId the company ID 481 * @param key the key 482 * @param start the lower bound of the range of asset category properties 483 * @param end the upper bound of the range of asset category properties (not inclusive) 484 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 485 * @return the ordered range of matching asset category properties 486 */ 487 public static List<AssetCategoryProperty> findByC_K(long companyId, 488 java.lang.String key, int start, int end, 489 OrderByComparator<AssetCategoryProperty> orderByComparator) { 490 return getPersistence() 491 .findByC_K(companyId, key, start, end, orderByComparator); 492 } 493 494 /** 495 * Returns an ordered range of all the asset category properties where companyId = ? and key = ?. 496 * 497 * <p> 498 * 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 AssetCategoryPropertyModelImpl}. 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. 499 * </p> 500 * 501 * @param companyId the company ID 502 * @param key the key 503 * @param start the lower bound of the range of asset category properties 504 * @param end the upper bound of the range of asset category properties (not inclusive) 505 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 506 * @param retrieveFromCache whether to retrieve from the finder cache 507 * @return the ordered range of matching asset category properties 508 */ 509 public static List<AssetCategoryProperty> findByC_K(long companyId, 510 java.lang.String key, int start, int end, 511 OrderByComparator<AssetCategoryProperty> orderByComparator, 512 boolean retrieveFromCache) { 513 return getPersistence() 514 .findByC_K(companyId, key, start, end, orderByComparator, 515 retrieveFromCache); 516 } 517 518 /** 519 * Returns the first asset category property in the ordered set where companyId = ? and key = ?. 520 * 521 * @param companyId the company ID 522 * @param key the key 523 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 524 * @return the first matching asset category property 525 * @throws NoSuchCategoryPropertyException if a matching asset category property could not be found 526 */ 527 public static AssetCategoryProperty findByC_K_First(long companyId, 528 java.lang.String key, 529 OrderByComparator<AssetCategoryProperty> orderByComparator) 530 throws com.liferay.portlet.asset.exception.NoSuchCategoryPropertyException { 531 return getPersistence() 532 .findByC_K_First(companyId, key, orderByComparator); 533 } 534 535 /** 536 * Returns the first asset category property in the ordered set where companyId = ? and key = ?. 537 * 538 * @param companyId the company ID 539 * @param key the key 540 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 541 * @return the first matching asset category property, or <code>null</code> if a matching asset category property could not be found 542 */ 543 public static AssetCategoryProperty fetchByC_K_First(long companyId, 544 java.lang.String key, 545 OrderByComparator<AssetCategoryProperty> orderByComparator) { 546 return getPersistence() 547 .fetchByC_K_First(companyId, key, orderByComparator); 548 } 549 550 /** 551 * Returns the last asset category property in the ordered set where companyId = ? and key = ?. 552 * 553 * @param companyId the company ID 554 * @param key the key 555 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 556 * @return the last matching asset category property 557 * @throws NoSuchCategoryPropertyException if a matching asset category property could not be found 558 */ 559 public static AssetCategoryProperty findByC_K_Last(long companyId, 560 java.lang.String key, 561 OrderByComparator<AssetCategoryProperty> orderByComparator) 562 throws com.liferay.portlet.asset.exception.NoSuchCategoryPropertyException { 563 return getPersistence().findByC_K_Last(companyId, key, orderByComparator); 564 } 565 566 /** 567 * Returns the last asset category property in the ordered set where companyId = ? and key = ?. 568 * 569 * @param companyId the company ID 570 * @param key the key 571 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 572 * @return the last matching asset category property, or <code>null</code> if a matching asset category property could not be found 573 */ 574 public static AssetCategoryProperty fetchByC_K_Last(long companyId, 575 java.lang.String key, 576 OrderByComparator<AssetCategoryProperty> orderByComparator) { 577 return getPersistence() 578 .fetchByC_K_Last(companyId, key, orderByComparator); 579 } 580 581 /** 582 * Returns the asset category properties before and after the current asset category property in the ordered set where companyId = ? and key = ?. 583 * 584 * @param categoryPropertyId the primary key of the current asset category property 585 * @param companyId the company ID 586 * @param key the key 587 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 588 * @return the previous, current, and next asset category property 589 * @throws NoSuchCategoryPropertyException if a asset category property with the primary key could not be found 590 */ 591 public static AssetCategoryProperty[] findByC_K_PrevAndNext( 592 long categoryPropertyId, long companyId, java.lang.String key, 593 OrderByComparator<AssetCategoryProperty> orderByComparator) 594 throws com.liferay.portlet.asset.exception.NoSuchCategoryPropertyException { 595 return getPersistence() 596 .findByC_K_PrevAndNext(categoryPropertyId, companyId, key, 597 orderByComparator); 598 } 599 600 /** 601 * Removes all the asset category properties where companyId = ? and key = ? from the database. 602 * 603 * @param companyId the company ID 604 * @param key the key 605 */ 606 public static void removeByC_K(long companyId, java.lang.String key) { 607 getPersistence().removeByC_K(companyId, key); 608 } 609 610 /** 611 * Returns the number of asset category properties where companyId = ? and key = ?. 612 * 613 * @param companyId the company ID 614 * @param key the key 615 * @return the number of matching asset category properties 616 */ 617 public static int countByC_K(long companyId, java.lang.String key) { 618 return getPersistence().countByC_K(companyId, key); 619 } 620 621 /** 622 * Returns the asset category property where categoryId = ? and key = ? or throws a {@link NoSuchCategoryPropertyException} if it could not be found. 623 * 624 * @param categoryId the category ID 625 * @param key the key 626 * @return the matching asset category property 627 * @throws NoSuchCategoryPropertyException if a matching asset category property could not be found 628 */ 629 public static AssetCategoryProperty findByCA_K(long categoryId, 630 java.lang.String key) 631 throws com.liferay.portlet.asset.exception.NoSuchCategoryPropertyException { 632 return getPersistence().findByCA_K(categoryId, key); 633 } 634 635 /** 636 * Returns the asset category property where categoryId = ? and key = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 637 * 638 * @param categoryId the category ID 639 * @param key the key 640 * @return the matching asset category property, or <code>null</code> if a matching asset category property could not be found 641 */ 642 public static AssetCategoryProperty fetchByCA_K(long categoryId, 643 java.lang.String key) { 644 return getPersistence().fetchByCA_K(categoryId, key); 645 } 646 647 /** 648 * Returns the asset category property where categoryId = ? and key = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 649 * 650 * @param categoryId the category ID 651 * @param key the key 652 * @param retrieveFromCache whether to retrieve from the finder cache 653 * @return the matching asset category property, or <code>null</code> if a matching asset category property could not be found 654 */ 655 public static AssetCategoryProperty fetchByCA_K(long categoryId, 656 java.lang.String key, boolean retrieveFromCache) { 657 return getPersistence().fetchByCA_K(categoryId, key, retrieveFromCache); 658 } 659 660 /** 661 * Removes the asset category property where categoryId = ? and key = ? from the database. 662 * 663 * @param categoryId the category ID 664 * @param key the key 665 * @return the asset category property that was removed 666 */ 667 public static AssetCategoryProperty removeByCA_K(long categoryId, 668 java.lang.String key) 669 throws com.liferay.portlet.asset.exception.NoSuchCategoryPropertyException { 670 return getPersistence().removeByCA_K(categoryId, key); 671 } 672 673 /** 674 * Returns the number of asset category properties where categoryId = ? and key = ?. 675 * 676 * @param categoryId the category ID 677 * @param key the key 678 * @return the number of matching asset category properties 679 */ 680 public static int countByCA_K(long categoryId, java.lang.String key) { 681 return getPersistence().countByCA_K(categoryId, key); 682 } 683 684 /** 685 * Caches the asset category property in the entity cache if it is enabled. 686 * 687 * @param assetCategoryProperty the asset category property 688 */ 689 public static void cacheResult(AssetCategoryProperty assetCategoryProperty) { 690 getPersistence().cacheResult(assetCategoryProperty); 691 } 692 693 /** 694 * Caches the asset category properties in the entity cache if it is enabled. 695 * 696 * @param assetCategoryProperties the asset category properties 697 */ 698 public static void cacheResult( 699 List<AssetCategoryProperty> assetCategoryProperties) { 700 getPersistence().cacheResult(assetCategoryProperties); 701 } 702 703 /** 704 * Creates a new asset category property with the primary key. Does not add the asset category property to the database. 705 * 706 * @param categoryPropertyId the primary key for the new asset category property 707 * @return the new asset category property 708 */ 709 public static AssetCategoryProperty create(long categoryPropertyId) { 710 return getPersistence().create(categoryPropertyId); 711 } 712 713 /** 714 * Removes the asset category property with the primary key from the database. Also notifies the appropriate model listeners. 715 * 716 * @param categoryPropertyId the primary key of the asset category property 717 * @return the asset category property that was removed 718 * @throws NoSuchCategoryPropertyException if a asset category property with the primary key could not be found 719 */ 720 public static AssetCategoryProperty remove(long categoryPropertyId) 721 throws com.liferay.portlet.asset.exception.NoSuchCategoryPropertyException { 722 return getPersistence().remove(categoryPropertyId); 723 } 724 725 public static AssetCategoryProperty updateImpl( 726 AssetCategoryProperty assetCategoryProperty) { 727 return getPersistence().updateImpl(assetCategoryProperty); 728 } 729 730 /** 731 * Returns the asset category property with the primary key or throws a {@link NoSuchCategoryPropertyException} if it could not be found. 732 * 733 * @param categoryPropertyId the primary key of the asset category property 734 * @return the asset category property 735 * @throws NoSuchCategoryPropertyException if a asset category property with the primary key could not be found 736 */ 737 public static AssetCategoryProperty findByPrimaryKey( 738 long categoryPropertyId) 739 throws com.liferay.portlet.asset.exception.NoSuchCategoryPropertyException { 740 return getPersistence().findByPrimaryKey(categoryPropertyId); 741 } 742 743 /** 744 * Returns the asset category property with the primary key or returns <code>null</code> if it could not be found. 745 * 746 * @param categoryPropertyId the primary key of the asset category property 747 * @return the asset category property, or <code>null</code> if a asset category property with the primary key could not be found 748 */ 749 public static AssetCategoryProperty fetchByPrimaryKey( 750 long categoryPropertyId) { 751 return getPersistence().fetchByPrimaryKey(categoryPropertyId); 752 } 753 754 public static java.util.Map<java.io.Serializable, AssetCategoryProperty> fetchByPrimaryKeys( 755 java.util.Set<java.io.Serializable> primaryKeys) { 756 return getPersistence().fetchByPrimaryKeys(primaryKeys); 757 } 758 759 /** 760 * Returns all the asset category properties. 761 * 762 * @return the asset category properties 763 */ 764 public static List<AssetCategoryProperty> findAll() { 765 return getPersistence().findAll(); 766 } 767 768 /** 769 * Returns a range of all the asset category properties. 770 * 771 * <p> 772 * 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 AssetCategoryPropertyModelImpl}. 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. 773 * </p> 774 * 775 * @param start the lower bound of the range of asset category properties 776 * @param end the upper bound of the range of asset category properties (not inclusive) 777 * @return the range of asset category properties 778 */ 779 public static List<AssetCategoryProperty> findAll(int start, int end) { 780 return getPersistence().findAll(start, end); 781 } 782 783 /** 784 * Returns an ordered range of all the asset category properties. 785 * 786 * <p> 787 * 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 AssetCategoryPropertyModelImpl}. 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. 788 * </p> 789 * 790 * @param start the lower bound of the range of asset category properties 791 * @param end the upper bound of the range of asset category properties (not inclusive) 792 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 793 * @return the ordered range of asset category properties 794 */ 795 public static List<AssetCategoryProperty> findAll(int start, int end, 796 OrderByComparator<AssetCategoryProperty> orderByComparator) { 797 return getPersistence().findAll(start, end, orderByComparator); 798 } 799 800 /** 801 * Returns an ordered range of all the asset category properties. 802 * 803 * <p> 804 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryPropertyModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 805 * </p> 806 * 807 * @param start the lower bound of the range of asset category properties 808 * @param end the upper bound of the range of asset category properties (not inclusive) 809 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 810 * @param retrieveFromCache whether to retrieve from the finder cache 811 * @return the ordered range of asset category properties 812 */ 813 public static List<AssetCategoryProperty> findAll(int start, int end, 814 OrderByComparator<AssetCategoryProperty> orderByComparator, 815 boolean retrieveFromCache) { 816 return getPersistence() 817 .findAll(start, end, orderByComparator, retrieveFromCache); 818 } 819 820 /** 821 * Removes all the asset category properties from the database. 822 */ 823 public static void removeAll() { 824 getPersistence().removeAll(); 825 } 826 827 /** 828 * Returns the number of asset category properties. 829 * 830 * @return the number of asset category properties 831 */ 832 public static int countAll() { 833 return getPersistence().countAll(); 834 } 835 836 public static java.util.Set<java.lang.String> getBadColumnNames() { 837 return getPersistence().getBadColumnNames(); 838 } 839 840 public static AssetCategoryPropertyPersistence getPersistence() { 841 if (_persistence == null) { 842 _persistence = (AssetCategoryPropertyPersistence)PortalBeanLocatorUtil.locate(AssetCategoryPropertyPersistence.class.getName()); 843 844 ReferenceRegistry.registerReference(AssetCategoryPropertyUtil.class, 845 "_persistence"); 846 } 847 848 return _persistence; 849 } 850 851 private static AssetCategoryPropertyPersistence _persistence; 852 }