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 an ordered range of all the ratings entries where uuid = ?. 159 * 160 * <p> 161 * 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. 162 * </p> 163 * 164 * @param uuid the uuid 165 * @param start the lower bound of the range of ratings entries 166 * @param end the upper bound of the range of ratings entries (not inclusive) 167 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 168 * @param retrieveFromCache whether to retrieve from the finder cache 169 * @return the ordered range of matching ratings entries 170 */ 171 public static List<RatingsEntry> findByUuid(java.lang.String uuid, 172 int start, int end, OrderByComparator<RatingsEntry> orderByComparator, 173 boolean retrieveFromCache) { 174 return getPersistence() 175 .findByUuid(uuid, start, end, orderByComparator, 176 retrieveFromCache); 177 } 178 179 /** 180 * Returns the first ratings entry in the ordered set where uuid = ?. 181 * 182 * @param uuid the uuid 183 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 184 * @return the first matching ratings entry 185 * @throws NoSuchEntryException if a matching ratings entry could not be found 186 */ 187 public static RatingsEntry findByUuid_First(java.lang.String uuid, 188 OrderByComparator<RatingsEntry> orderByComparator) 189 throws com.liferay.portlet.ratings.NoSuchEntryException { 190 return getPersistence().findByUuid_First(uuid, orderByComparator); 191 } 192 193 /** 194 * Returns the first ratings entry in the ordered set where uuid = ?. 195 * 196 * @param uuid the uuid 197 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 198 * @return the first matching ratings entry, or <code>null</code> if a matching ratings entry could not be found 199 */ 200 public static RatingsEntry fetchByUuid_First(java.lang.String uuid, 201 OrderByComparator<RatingsEntry> orderByComparator) { 202 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 203 } 204 205 /** 206 * Returns the last ratings entry in the ordered set where uuid = ?. 207 * 208 * @param uuid the uuid 209 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 210 * @return the last matching ratings entry 211 * @throws NoSuchEntryException if a matching ratings entry could not be found 212 */ 213 public static RatingsEntry findByUuid_Last(java.lang.String uuid, 214 OrderByComparator<RatingsEntry> orderByComparator) 215 throws com.liferay.portlet.ratings.NoSuchEntryException { 216 return getPersistence().findByUuid_Last(uuid, orderByComparator); 217 } 218 219 /** 220 * Returns the last ratings entry in the ordered set where uuid = ?. 221 * 222 * @param uuid the uuid 223 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 224 * @return the last matching ratings entry, or <code>null</code> if a matching ratings entry could not be found 225 */ 226 public static RatingsEntry fetchByUuid_Last(java.lang.String uuid, 227 OrderByComparator<RatingsEntry> orderByComparator) { 228 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 229 } 230 231 /** 232 * Returns the ratings entries before and after the current ratings entry in the ordered set where uuid = ?. 233 * 234 * @param entryId the primary key of the current ratings entry 235 * @param uuid the uuid 236 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 237 * @return the previous, current, and next ratings entry 238 * @throws NoSuchEntryException if a ratings entry with the primary key could not be found 239 */ 240 public static RatingsEntry[] findByUuid_PrevAndNext(long entryId, 241 java.lang.String uuid, OrderByComparator<RatingsEntry> orderByComparator) 242 throws com.liferay.portlet.ratings.NoSuchEntryException { 243 return getPersistence() 244 .findByUuid_PrevAndNext(entryId, uuid, orderByComparator); 245 } 246 247 /** 248 * Removes all the ratings entries where uuid = ? from the database. 249 * 250 * @param uuid the uuid 251 */ 252 public static void removeByUuid(java.lang.String uuid) { 253 getPersistence().removeByUuid(uuid); 254 } 255 256 /** 257 * Returns the number of ratings entries where uuid = ?. 258 * 259 * @param uuid the uuid 260 * @return the number of matching ratings entries 261 */ 262 public static int countByUuid(java.lang.String uuid) { 263 return getPersistence().countByUuid(uuid); 264 } 265 266 /** 267 * Returns all the ratings entries where uuid = ? and companyId = ?. 268 * 269 * @param uuid the uuid 270 * @param companyId the company ID 271 * @return the matching ratings entries 272 */ 273 public static List<RatingsEntry> findByUuid_C(java.lang.String uuid, 274 long companyId) { 275 return getPersistence().findByUuid_C(uuid, companyId); 276 } 277 278 /** 279 * Returns a range of all the ratings entries where uuid = ? and companyId = ?. 280 * 281 * <p> 282 * 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. 283 * </p> 284 * 285 * @param uuid the uuid 286 * @param companyId the company ID 287 * @param start the lower bound of the range of ratings entries 288 * @param end the upper bound of the range of ratings entries (not inclusive) 289 * @return the range of matching ratings entries 290 */ 291 public static List<RatingsEntry> findByUuid_C(java.lang.String uuid, 292 long companyId, int start, int end) { 293 return getPersistence().findByUuid_C(uuid, companyId, start, end); 294 } 295 296 /** 297 * Returns an ordered range of all the ratings entries where uuid = ? and companyId = ?. 298 * 299 * <p> 300 * 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. 301 * </p> 302 * 303 * @param uuid the uuid 304 * @param companyId the company ID 305 * @param start the lower bound of the range of ratings entries 306 * @param end the upper bound of the range of ratings entries (not inclusive) 307 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 308 * @return the ordered range of matching ratings entries 309 */ 310 public static List<RatingsEntry> findByUuid_C(java.lang.String uuid, 311 long companyId, int start, int end, 312 OrderByComparator<RatingsEntry> orderByComparator) { 313 return getPersistence() 314 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 315 } 316 317 /** 318 * Returns an ordered range of all the ratings entries where uuid = ? and companyId = ?. 319 * 320 * <p> 321 * 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. 322 * </p> 323 * 324 * @param uuid the uuid 325 * @param companyId the company ID 326 * @param start the lower bound of the range of ratings entries 327 * @param end the upper bound of the range of ratings entries (not inclusive) 328 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 329 * @param retrieveFromCache whether to retrieve from the finder cache 330 * @return the ordered range of matching ratings entries 331 */ 332 public static List<RatingsEntry> findByUuid_C(java.lang.String uuid, 333 long companyId, int start, int end, 334 OrderByComparator<RatingsEntry> orderByComparator, 335 boolean retrieveFromCache) { 336 return getPersistence() 337 .findByUuid_C(uuid, companyId, start, end, 338 orderByComparator, retrieveFromCache); 339 } 340 341 /** 342 * Returns the first 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 first matching ratings entry 348 * @throws NoSuchEntryException if a matching ratings entry could not be found 349 */ 350 public static RatingsEntry findByUuid_C_First(java.lang.String uuid, 351 long companyId, OrderByComparator<RatingsEntry> orderByComparator) 352 throws com.liferay.portlet.ratings.NoSuchEntryException { 353 return getPersistence() 354 .findByUuid_C_First(uuid, companyId, orderByComparator); 355 } 356 357 /** 358 * Returns the first ratings entry in the ordered set where uuid = ? and companyId = ?. 359 * 360 * @param uuid the uuid 361 * @param companyId the company ID 362 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 363 * @return the first matching ratings entry, or <code>null</code> if a matching ratings entry could not be found 364 */ 365 public static RatingsEntry fetchByUuid_C_First(java.lang.String uuid, 366 long companyId, OrderByComparator<RatingsEntry> orderByComparator) { 367 return getPersistence() 368 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 369 } 370 371 /** 372 * Returns the last ratings entry in the ordered set where uuid = ? and companyId = ?. 373 * 374 * @param uuid the uuid 375 * @param companyId the company ID 376 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 377 * @return the last matching ratings entry 378 * @throws NoSuchEntryException if a matching ratings entry could not be found 379 */ 380 public static RatingsEntry findByUuid_C_Last(java.lang.String uuid, 381 long companyId, OrderByComparator<RatingsEntry> orderByComparator) 382 throws com.liferay.portlet.ratings.NoSuchEntryException { 383 return getPersistence() 384 .findByUuid_C_Last(uuid, companyId, orderByComparator); 385 } 386 387 /** 388 * Returns the last ratings entry in the ordered set where uuid = ? and companyId = ?. 389 * 390 * @param uuid the uuid 391 * @param companyId the company ID 392 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 393 * @return the last matching ratings entry, or <code>null</code> if a matching ratings entry could not be found 394 */ 395 public static RatingsEntry fetchByUuid_C_Last(java.lang.String uuid, 396 long companyId, OrderByComparator<RatingsEntry> orderByComparator) { 397 return getPersistence() 398 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 399 } 400 401 /** 402 * Returns the ratings entries before and after the current ratings entry in the ordered set where uuid = ? and companyId = ?. 403 * 404 * @param entryId the primary key of the current ratings entry 405 * @param uuid the uuid 406 * @param companyId the company ID 407 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 408 * @return the previous, current, and next ratings entry 409 * @throws NoSuchEntryException if a ratings entry with the primary key could not be found 410 */ 411 public static RatingsEntry[] findByUuid_C_PrevAndNext(long entryId, 412 java.lang.String uuid, long companyId, 413 OrderByComparator<RatingsEntry> orderByComparator) 414 throws com.liferay.portlet.ratings.NoSuchEntryException { 415 return getPersistence() 416 .findByUuid_C_PrevAndNext(entryId, uuid, companyId, 417 orderByComparator); 418 } 419 420 /** 421 * Removes all the ratings entries where uuid = ? and companyId = ? from the database. 422 * 423 * @param uuid the uuid 424 * @param companyId the company ID 425 */ 426 public static void removeByUuid_C(java.lang.String uuid, long companyId) { 427 getPersistence().removeByUuid_C(uuid, companyId); 428 } 429 430 /** 431 * Returns the number of ratings entries where uuid = ? and companyId = ?. 432 * 433 * @param uuid the uuid 434 * @param companyId the company ID 435 * @return the number of matching ratings entries 436 */ 437 public static int countByUuid_C(java.lang.String uuid, long companyId) { 438 return getPersistence().countByUuid_C(uuid, companyId); 439 } 440 441 /** 442 * Returns all the ratings entries where classNameId = ? and classPK = ?. 443 * 444 * @param classNameId the class name ID 445 * @param classPK the class p k 446 * @return the matching ratings entries 447 */ 448 public static List<RatingsEntry> findByC_C(long classNameId, long classPK) { 449 return getPersistence().findByC_C(classNameId, classPK); 450 } 451 452 /** 453 * Returns a range of all the ratings entries where classNameId = ? and classPK = ?. 454 * 455 * <p> 456 * 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. 457 * </p> 458 * 459 * @param classNameId the class name ID 460 * @param classPK the class p k 461 * @param start the lower bound of the range of ratings entries 462 * @param end the upper bound of the range of ratings entries (not inclusive) 463 * @return the range of matching ratings entries 464 */ 465 public static List<RatingsEntry> findByC_C(long classNameId, long classPK, 466 int start, int end) { 467 return getPersistence().findByC_C(classNameId, classPK, start, end); 468 } 469 470 /** 471 * Returns an ordered range of all the ratings entries where classNameId = ? and classPK = ?. 472 * 473 * <p> 474 * 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. 475 * </p> 476 * 477 * @param classNameId the class name ID 478 * @param classPK the class p k 479 * @param start the lower bound of the range of ratings entries 480 * @param end the upper bound of the range of ratings entries (not inclusive) 481 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 482 * @return the ordered range of matching ratings entries 483 */ 484 public static List<RatingsEntry> findByC_C(long classNameId, long classPK, 485 int start, int end, OrderByComparator<RatingsEntry> orderByComparator) { 486 return getPersistence() 487 .findByC_C(classNameId, classPK, start, end, 488 orderByComparator); 489 } 490 491 /** 492 * Returns an ordered range of all the ratings entries where classNameId = ? and classPK = ?. 493 * 494 * <p> 495 * 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. 496 * </p> 497 * 498 * @param classNameId the class name ID 499 * @param classPK the class p k 500 * @param start the lower bound of the range of ratings entries 501 * @param end the upper bound of the range of ratings entries (not inclusive) 502 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 503 * @param retrieveFromCache whether to retrieve from the finder cache 504 * @return the ordered range of matching ratings entries 505 */ 506 public static List<RatingsEntry> findByC_C(long classNameId, long classPK, 507 int start, int end, OrderByComparator<RatingsEntry> orderByComparator, 508 boolean retrieveFromCache) { 509 return getPersistence() 510 .findByC_C(classNameId, classPK, start, end, 511 orderByComparator, retrieveFromCache); 512 } 513 514 /** 515 * Returns the first ratings entry in the ordered set where classNameId = ? and classPK = ?. 516 * 517 * @param classNameId the class name ID 518 * @param classPK the class p k 519 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 520 * @return the first matching ratings entry 521 * @throws NoSuchEntryException if a matching ratings entry could not be found 522 */ 523 public static RatingsEntry findByC_C_First(long classNameId, long classPK, 524 OrderByComparator<RatingsEntry> orderByComparator) 525 throws com.liferay.portlet.ratings.NoSuchEntryException { 526 return getPersistence() 527 .findByC_C_First(classNameId, classPK, orderByComparator); 528 } 529 530 /** 531 * Returns the first ratings entry in the ordered set where classNameId = ? and classPK = ?. 532 * 533 * @param classNameId the class name ID 534 * @param classPK the class p k 535 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 536 * @return the first matching ratings entry, or <code>null</code> if a matching ratings entry could not be found 537 */ 538 public static RatingsEntry fetchByC_C_First(long classNameId, long classPK, 539 OrderByComparator<RatingsEntry> orderByComparator) { 540 return getPersistence() 541 .fetchByC_C_First(classNameId, classPK, orderByComparator); 542 } 543 544 /** 545 * Returns the last ratings entry in the ordered set where classNameId = ? and classPK = ?. 546 * 547 * @param classNameId the class name ID 548 * @param classPK the class p k 549 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 550 * @return the last matching ratings entry 551 * @throws NoSuchEntryException if a matching ratings entry could not be found 552 */ 553 public static RatingsEntry findByC_C_Last(long classNameId, long classPK, 554 OrderByComparator<RatingsEntry> orderByComparator) 555 throws com.liferay.portlet.ratings.NoSuchEntryException { 556 return getPersistence() 557 .findByC_C_Last(classNameId, classPK, orderByComparator); 558 } 559 560 /** 561 * Returns the last ratings entry in the ordered set where classNameId = ? and classPK = ?. 562 * 563 * @param classNameId the class name ID 564 * @param classPK the class p k 565 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 566 * @return the last matching ratings entry, or <code>null</code> if a matching ratings entry could not be found 567 */ 568 public static RatingsEntry fetchByC_C_Last(long classNameId, long classPK, 569 OrderByComparator<RatingsEntry> orderByComparator) { 570 return getPersistence() 571 .fetchByC_C_Last(classNameId, classPK, orderByComparator); 572 } 573 574 /** 575 * Returns the ratings entries before and after the current ratings entry in the ordered set where classNameId = ? and classPK = ?. 576 * 577 * @param entryId the primary key of the current ratings entry 578 * @param classNameId the class name ID 579 * @param classPK the class p k 580 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 581 * @return the previous, current, and next ratings entry 582 * @throws NoSuchEntryException if a ratings entry with the primary key could not be found 583 */ 584 public static RatingsEntry[] findByC_C_PrevAndNext(long entryId, 585 long classNameId, long classPK, 586 OrderByComparator<RatingsEntry> orderByComparator) 587 throws com.liferay.portlet.ratings.NoSuchEntryException { 588 return getPersistence() 589 .findByC_C_PrevAndNext(entryId, classNameId, classPK, 590 orderByComparator); 591 } 592 593 /** 594 * Removes all the ratings entries where classNameId = ? and classPK = ? from the database. 595 * 596 * @param classNameId the class name ID 597 * @param classPK the class p k 598 */ 599 public static void removeByC_C(long classNameId, long classPK) { 600 getPersistence().removeByC_C(classNameId, classPK); 601 } 602 603 /** 604 * Returns the number of ratings entries where classNameId = ? and classPK = ?. 605 * 606 * @param classNameId the class name ID 607 * @param classPK the class p k 608 * @return the number of matching ratings entries 609 */ 610 public static int countByC_C(long classNameId, long classPK) { 611 return getPersistence().countByC_C(classNameId, classPK); 612 } 613 614 /** 615 * Returns the ratings entry where userId = ? and classNameId = ? and classPK = ? or throws a {@link NoSuchEntryException} if it could not be found. 616 * 617 * @param userId the user ID 618 * @param classNameId the class name ID 619 * @param classPK the class p k 620 * @return the matching ratings entry 621 * @throws NoSuchEntryException if a matching ratings entry could not be found 622 */ 623 public static RatingsEntry findByU_C_C(long userId, long classNameId, 624 long classPK) throws com.liferay.portlet.ratings.NoSuchEntryException { 625 return getPersistence().findByU_C_C(userId, classNameId, classPK); 626 } 627 628 /** 629 * 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. 630 * 631 * @param userId the user ID 632 * @param classNameId the class name ID 633 * @param classPK the class p k 634 * @return the matching ratings entry, or <code>null</code> if a matching ratings entry could not be found 635 */ 636 public static RatingsEntry fetchByU_C_C(long userId, long classNameId, 637 long classPK) { 638 return getPersistence().fetchByU_C_C(userId, classNameId, classPK); 639 } 640 641 /** 642 * 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. 643 * 644 * @param userId the user ID 645 * @param classNameId the class name ID 646 * @param classPK the class p k 647 * @param retrieveFromCache whether to retrieve from the finder cache 648 * @return the matching ratings entry, or <code>null</code> if a matching ratings entry could not be found 649 */ 650 public static RatingsEntry fetchByU_C_C(long userId, long classNameId, 651 long classPK, boolean retrieveFromCache) { 652 return getPersistence() 653 .fetchByU_C_C(userId, classNameId, classPK, retrieveFromCache); 654 } 655 656 /** 657 * Removes the ratings entry where userId = ? and classNameId = ? and classPK = ? from the database. 658 * 659 * @param userId the user ID 660 * @param classNameId the class name ID 661 * @param classPK the class p k 662 * @return the ratings entry that was removed 663 */ 664 public static RatingsEntry removeByU_C_C(long userId, long classNameId, 665 long classPK) throws com.liferay.portlet.ratings.NoSuchEntryException { 666 return getPersistence().removeByU_C_C(userId, classNameId, classPK); 667 } 668 669 /** 670 * Returns the number of ratings entries where userId = ? and classNameId = ? and classPK = ?. 671 * 672 * @param userId the user ID 673 * @param classNameId the class name ID 674 * @param classPK the class p k 675 * @return the number of matching ratings entries 676 */ 677 public static int countByU_C_C(long userId, long classNameId, long classPK) { 678 return getPersistence().countByU_C_C(userId, classNameId, classPK); 679 } 680 681 /** 682 * Returns all the ratings entries where classNameId = ? and classPK = ? and score = ?. 683 * 684 * @param classNameId the class name ID 685 * @param classPK the class p k 686 * @param score the score 687 * @return the matching ratings entries 688 */ 689 public static List<RatingsEntry> findByC_C_S(long classNameId, 690 long classPK, double score) { 691 return getPersistence().findByC_C_S(classNameId, classPK, score); 692 } 693 694 /** 695 * Returns a range of all the ratings entries where classNameId = ? and classPK = ? and score = ?. 696 * 697 * <p> 698 * 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. 699 * </p> 700 * 701 * @param classNameId the class name ID 702 * @param classPK the class p k 703 * @param score the score 704 * @param start the lower bound of the range of ratings entries 705 * @param end the upper bound of the range of ratings entries (not inclusive) 706 * @return the range of matching ratings entries 707 */ 708 public static List<RatingsEntry> findByC_C_S(long classNameId, 709 long classPK, double score, int start, int end) { 710 return getPersistence() 711 .findByC_C_S(classNameId, classPK, score, start, end); 712 } 713 714 /** 715 * Returns an ordered range of all the ratings entries where classNameId = ? and classPK = ? and score = ?. 716 * 717 * <p> 718 * 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. 719 * </p> 720 * 721 * @param classNameId the class name ID 722 * @param classPK the class p k 723 * @param score the score 724 * @param start the lower bound of the range of ratings entries 725 * @param end the upper bound of the range of ratings entries (not inclusive) 726 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 727 * @return the ordered range of matching ratings entries 728 */ 729 public static List<RatingsEntry> findByC_C_S(long classNameId, 730 long classPK, double score, int start, int end, 731 OrderByComparator<RatingsEntry> orderByComparator) { 732 return getPersistence() 733 .findByC_C_S(classNameId, classPK, score, start, end, 734 orderByComparator); 735 } 736 737 /** 738 * Returns an ordered range of all the ratings entries where classNameId = ? and classPK = ? and score = ?. 739 * 740 * <p> 741 * 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. 742 * </p> 743 * 744 * @param classNameId the class name ID 745 * @param classPK the class p k 746 * @param score the score 747 * @param start the lower bound of the range of ratings entries 748 * @param end the upper bound of the range of ratings entries (not inclusive) 749 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 750 * @param retrieveFromCache whether to retrieve from the finder cache 751 * @return the ordered range of matching ratings entries 752 */ 753 public static List<RatingsEntry> findByC_C_S(long classNameId, 754 long classPK, double score, int start, int end, 755 OrderByComparator<RatingsEntry> orderByComparator, 756 boolean retrieveFromCache) { 757 return getPersistence() 758 .findByC_C_S(classNameId, classPK, score, start, end, 759 orderByComparator, retrieveFromCache); 760 } 761 762 /** 763 * Returns the first ratings entry in the ordered set where classNameId = ? and classPK = ? and score = ?. 764 * 765 * @param classNameId the class name ID 766 * @param classPK the class p k 767 * @param score the score 768 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 769 * @return the first matching ratings entry 770 * @throws NoSuchEntryException if a matching ratings entry could not be found 771 */ 772 public static RatingsEntry findByC_C_S_First(long classNameId, 773 long classPK, double score, 774 OrderByComparator<RatingsEntry> orderByComparator) 775 throws com.liferay.portlet.ratings.NoSuchEntryException { 776 return getPersistence() 777 .findByC_C_S_First(classNameId, classPK, score, 778 orderByComparator); 779 } 780 781 /** 782 * Returns the first ratings entry in the ordered set where classNameId = ? and classPK = ? and score = ?. 783 * 784 * @param classNameId the class name ID 785 * @param classPK the class p k 786 * @param score the score 787 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 788 * @return the first matching ratings entry, or <code>null</code> if a matching ratings entry could not be found 789 */ 790 public static RatingsEntry fetchByC_C_S_First(long classNameId, 791 long classPK, double score, 792 OrderByComparator<RatingsEntry> orderByComparator) { 793 return getPersistence() 794 .fetchByC_C_S_First(classNameId, classPK, score, 795 orderByComparator); 796 } 797 798 /** 799 * Returns the last ratings entry in the ordered set where classNameId = ? and classPK = ? and score = ?. 800 * 801 * @param classNameId the class name ID 802 * @param classPK the class p k 803 * @param score the score 804 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 805 * @return the last matching ratings entry 806 * @throws NoSuchEntryException if a matching ratings entry could not be found 807 */ 808 public static RatingsEntry findByC_C_S_Last(long classNameId, long classPK, 809 double score, OrderByComparator<RatingsEntry> orderByComparator) 810 throws com.liferay.portlet.ratings.NoSuchEntryException { 811 return getPersistence() 812 .findByC_C_S_Last(classNameId, classPK, score, 813 orderByComparator); 814 } 815 816 /** 817 * Returns the last ratings entry in the ordered set where classNameId = ? and classPK = ? and score = ?. 818 * 819 * @param classNameId the class name ID 820 * @param classPK the class p k 821 * @param score the score 822 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 823 * @return the last matching ratings entry, or <code>null</code> if a matching ratings entry could not be found 824 */ 825 public static RatingsEntry fetchByC_C_S_Last(long classNameId, 826 long classPK, double score, 827 OrderByComparator<RatingsEntry> orderByComparator) { 828 return getPersistence() 829 .fetchByC_C_S_Last(classNameId, classPK, score, 830 orderByComparator); 831 } 832 833 /** 834 * Returns the ratings entries before and after the current ratings entry in the ordered set where classNameId = ? and classPK = ? and score = ?. 835 * 836 * @param entryId the primary key of the current ratings entry 837 * @param classNameId the class name ID 838 * @param classPK the class p k 839 * @param score the score 840 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 841 * @return the previous, current, and next ratings entry 842 * @throws NoSuchEntryException if a ratings entry with the primary key could not be found 843 */ 844 public static RatingsEntry[] findByC_C_S_PrevAndNext(long entryId, 845 long classNameId, long classPK, double score, 846 OrderByComparator<RatingsEntry> orderByComparator) 847 throws com.liferay.portlet.ratings.NoSuchEntryException { 848 return getPersistence() 849 .findByC_C_S_PrevAndNext(entryId, classNameId, classPK, 850 score, orderByComparator); 851 } 852 853 /** 854 * Removes all the ratings entries where classNameId = ? and classPK = ? and score = ? from the database. 855 * 856 * @param classNameId the class name ID 857 * @param classPK the class p k 858 * @param score the score 859 */ 860 public static void removeByC_C_S(long classNameId, long classPK, 861 double score) { 862 getPersistence().removeByC_C_S(classNameId, classPK, score); 863 } 864 865 /** 866 * Returns the number of ratings entries where classNameId = ? and classPK = ? and score = ?. 867 * 868 * @param classNameId the class name ID 869 * @param classPK the class p k 870 * @param score the score 871 * @return the number of matching ratings entries 872 */ 873 public static int countByC_C_S(long classNameId, long classPK, double score) { 874 return getPersistence().countByC_C_S(classNameId, classPK, score); 875 } 876 877 /** 878 * Caches the ratings entry in the entity cache if it is enabled. 879 * 880 * @param ratingsEntry the ratings entry 881 */ 882 public static void cacheResult(RatingsEntry ratingsEntry) { 883 getPersistence().cacheResult(ratingsEntry); 884 } 885 886 /** 887 * Caches the ratings entries in the entity cache if it is enabled. 888 * 889 * @param ratingsEntries the ratings entries 890 */ 891 public static void cacheResult(List<RatingsEntry> ratingsEntries) { 892 getPersistence().cacheResult(ratingsEntries); 893 } 894 895 /** 896 * Creates a new ratings entry with the primary key. Does not add the ratings entry to the database. 897 * 898 * @param entryId the primary key for the new ratings entry 899 * @return the new ratings entry 900 */ 901 public static RatingsEntry create(long entryId) { 902 return getPersistence().create(entryId); 903 } 904 905 /** 906 * Removes the ratings entry with the primary key from the database. Also notifies the appropriate model listeners. 907 * 908 * @param entryId the primary key of the ratings entry 909 * @return the ratings entry that was removed 910 * @throws NoSuchEntryException if a ratings entry with the primary key could not be found 911 */ 912 public static RatingsEntry remove(long entryId) 913 throws com.liferay.portlet.ratings.NoSuchEntryException { 914 return getPersistence().remove(entryId); 915 } 916 917 public static RatingsEntry updateImpl(RatingsEntry ratingsEntry) { 918 return getPersistence().updateImpl(ratingsEntry); 919 } 920 921 /** 922 * Returns the ratings entry with the primary key or throws a {@link NoSuchEntryException} if it could not be found. 923 * 924 * @param entryId the primary key of the ratings entry 925 * @return the ratings entry 926 * @throws NoSuchEntryException if a ratings entry with the primary key could not be found 927 */ 928 public static RatingsEntry findByPrimaryKey(long entryId) 929 throws com.liferay.portlet.ratings.NoSuchEntryException { 930 return getPersistence().findByPrimaryKey(entryId); 931 } 932 933 /** 934 * Returns the ratings entry with the primary key or returns <code>null</code> if it could not be found. 935 * 936 * @param entryId the primary key of the ratings entry 937 * @return the ratings entry, or <code>null</code> if a ratings entry with the primary key could not be found 938 */ 939 public static RatingsEntry fetchByPrimaryKey(long entryId) { 940 return getPersistence().fetchByPrimaryKey(entryId); 941 } 942 943 public static java.util.Map<java.io.Serializable, RatingsEntry> fetchByPrimaryKeys( 944 java.util.Set<java.io.Serializable> primaryKeys) { 945 return getPersistence().fetchByPrimaryKeys(primaryKeys); 946 } 947 948 /** 949 * Returns all the ratings entries. 950 * 951 * @return the ratings entries 952 */ 953 public static List<RatingsEntry> findAll() { 954 return getPersistence().findAll(); 955 } 956 957 /** 958 * Returns a range of all the ratings entries. 959 * 960 * <p> 961 * 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. 962 * </p> 963 * 964 * @param start the lower bound of the range of ratings entries 965 * @param end the upper bound of the range of ratings entries (not inclusive) 966 * @return the range of ratings entries 967 */ 968 public static List<RatingsEntry> findAll(int start, int end) { 969 return getPersistence().findAll(start, end); 970 } 971 972 /** 973 * Returns an ordered range of all the ratings entries. 974 * 975 * <p> 976 * 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. 977 * </p> 978 * 979 * @param start the lower bound of the range of ratings entries 980 * @param end the upper bound of the range of ratings entries (not inclusive) 981 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 982 * @return the ordered range of ratings entries 983 */ 984 public static List<RatingsEntry> findAll(int start, int end, 985 OrderByComparator<RatingsEntry> orderByComparator) { 986 return getPersistence().findAll(start, end, orderByComparator); 987 } 988 989 /** 990 * Returns an ordered range of all the ratings entries. 991 * 992 * <p> 993 * 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. 994 * </p> 995 * 996 * @param start the lower bound of the range of ratings entries 997 * @param end the upper bound of the range of ratings entries (not inclusive) 998 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 999 * @param retrieveFromCache whether to retrieve from the finder cache 1000 * @return the ordered range of ratings entries 1001 */ 1002 public static List<RatingsEntry> findAll(int start, int end, 1003 OrderByComparator<RatingsEntry> orderByComparator, 1004 boolean retrieveFromCache) { 1005 return getPersistence() 1006 .findAll(start, end, orderByComparator, retrieveFromCache); 1007 } 1008 1009 /** 1010 * Removes all the ratings entries from the database. 1011 */ 1012 public static void removeAll() { 1013 getPersistence().removeAll(); 1014 } 1015 1016 /** 1017 * Returns the number of ratings entries. 1018 * 1019 * @return the number of ratings entries 1020 */ 1021 public static int countAll() { 1022 return getPersistence().countAll(); 1023 } 1024 1025 public static java.util.Set<java.lang.String> getBadColumnNames() { 1026 return getPersistence().getBadColumnNames(); 1027 } 1028 1029 public static RatingsEntryPersistence getPersistence() { 1030 if (_persistence == null) { 1031 _persistence = (RatingsEntryPersistence)PortalBeanLocatorUtil.locate(RatingsEntryPersistence.class.getName()); 1032 1033 ReferenceRegistry.registerReference(RatingsEntryUtil.class, 1034 "_persistence"); 1035 } 1036 1037 return _persistence; 1038 } 1039 1040 /** 1041 * @deprecated As of 6.2.0 1042 */ 1043 @Deprecated 1044 public void setPersistence(RatingsEntryPersistence persistence) { 1045 } 1046 1047 private static RatingsEntryPersistence _persistence; 1048 }