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