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.exception.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.exception.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.exception.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.exception.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.exception.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.exception.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.exception.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.exception.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.exception.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) 625 throws com.liferay.portlet.ratings.exception.NoSuchEntryException { 626 return getPersistence().findByU_C_C(userId, classNameId, classPK); 627 } 628 629 /** 630 * 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. 631 * 632 * @param userId the user ID 633 * @param classNameId the class name ID 634 * @param classPK the class p k 635 * @return the matching ratings entry, or <code>null</code> if a matching ratings entry could not be found 636 */ 637 public static RatingsEntry fetchByU_C_C(long userId, long classNameId, 638 long classPK) { 639 return getPersistence().fetchByU_C_C(userId, classNameId, classPK); 640 } 641 642 /** 643 * 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. 644 * 645 * @param userId the user ID 646 * @param classNameId the class name ID 647 * @param classPK the class p k 648 * @param retrieveFromCache whether to retrieve from the finder cache 649 * @return the matching ratings entry, or <code>null</code> if a matching ratings entry could not be found 650 */ 651 public static RatingsEntry fetchByU_C_C(long userId, long classNameId, 652 long classPK, boolean retrieveFromCache) { 653 return getPersistence() 654 .fetchByU_C_C(userId, classNameId, classPK, retrieveFromCache); 655 } 656 657 /** 658 * Removes the ratings entry where userId = ? and classNameId = ? and classPK = ? from the database. 659 * 660 * @param userId the user ID 661 * @param classNameId the class name ID 662 * @param classPK the class p k 663 * @return the ratings entry that was removed 664 */ 665 public static RatingsEntry removeByU_C_C(long userId, long classNameId, 666 long classPK) 667 throws com.liferay.portlet.ratings.exception.NoSuchEntryException { 668 return getPersistence().removeByU_C_C(userId, classNameId, classPK); 669 } 670 671 /** 672 * Returns the number of ratings entries where userId = ? and classNameId = ? and classPK = ?. 673 * 674 * @param userId the user ID 675 * @param classNameId the class name ID 676 * @param classPK the class p k 677 * @return the number of matching ratings entries 678 */ 679 public static int countByU_C_C(long userId, long classNameId, long classPK) { 680 return getPersistence().countByU_C_C(userId, classNameId, classPK); 681 } 682 683 /** 684 * Returns all the ratings entries where classNameId = ? and classPK = ? and score = ?. 685 * 686 * @param classNameId the class name ID 687 * @param classPK the class p k 688 * @param score the score 689 * @return the matching ratings entries 690 */ 691 public static List<RatingsEntry> findByC_C_S(long classNameId, 692 long classPK, double score) { 693 return getPersistence().findByC_C_S(classNameId, classPK, score); 694 } 695 696 /** 697 * Returns a range of all the ratings entries where classNameId = ? and classPK = ? and score = ?. 698 * 699 * <p> 700 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 701 * </p> 702 * 703 * @param classNameId the class name ID 704 * @param classPK the class p k 705 * @param score the score 706 * @param start the lower bound of the range of ratings entries 707 * @param end the upper bound of the range of ratings entries (not inclusive) 708 * @return the range of matching ratings entries 709 */ 710 public static List<RatingsEntry> findByC_C_S(long classNameId, 711 long classPK, double score, int start, int end) { 712 return getPersistence() 713 .findByC_C_S(classNameId, classPK, score, start, end); 714 } 715 716 /** 717 * Returns an ordered range of all the ratings entries where classNameId = ? and classPK = ? and score = ?. 718 * 719 * <p> 720 * 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. 721 * </p> 722 * 723 * @param classNameId the class name ID 724 * @param classPK the class p k 725 * @param score the score 726 * @param start the lower bound of the range of ratings entries 727 * @param end the upper bound of the range of ratings entries (not inclusive) 728 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 729 * @return the ordered range of matching ratings entries 730 */ 731 public static List<RatingsEntry> findByC_C_S(long classNameId, 732 long classPK, double score, int start, int end, 733 OrderByComparator<RatingsEntry> orderByComparator) { 734 return getPersistence() 735 .findByC_C_S(classNameId, classPK, score, start, end, 736 orderByComparator); 737 } 738 739 /** 740 * Returns an ordered range of all the ratings entries where classNameId = ? and classPK = ? and score = ?. 741 * 742 * <p> 743 * 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. 744 * </p> 745 * 746 * @param classNameId the class name ID 747 * @param classPK the class p k 748 * @param score the score 749 * @param start the lower bound of the range of ratings entries 750 * @param end the upper bound of the range of ratings entries (not inclusive) 751 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 752 * @param retrieveFromCache whether to retrieve from the finder cache 753 * @return the ordered range of matching ratings entries 754 */ 755 public static List<RatingsEntry> findByC_C_S(long classNameId, 756 long classPK, double score, int start, int end, 757 OrderByComparator<RatingsEntry> orderByComparator, 758 boolean retrieveFromCache) { 759 return getPersistence() 760 .findByC_C_S(classNameId, classPK, score, start, end, 761 orderByComparator, retrieveFromCache); 762 } 763 764 /** 765 * Returns the first ratings entry in the ordered set where classNameId = ? and classPK = ? and score = ?. 766 * 767 * @param classNameId the class name ID 768 * @param classPK the class p k 769 * @param score the score 770 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 771 * @return the first matching ratings entry 772 * @throws NoSuchEntryException if a matching ratings entry could not be found 773 */ 774 public static RatingsEntry findByC_C_S_First(long classNameId, 775 long classPK, double score, 776 OrderByComparator<RatingsEntry> orderByComparator) 777 throws com.liferay.portlet.ratings.exception.NoSuchEntryException { 778 return getPersistence() 779 .findByC_C_S_First(classNameId, classPK, score, 780 orderByComparator); 781 } 782 783 /** 784 * Returns the first ratings entry in the ordered set where classNameId = ? and classPK = ? and score = ?. 785 * 786 * @param classNameId the class name ID 787 * @param classPK the class p k 788 * @param score the score 789 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 790 * @return the first matching ratings entry, or <code>null</code> if a matching ratings entry could not be found 791 */ 792 public static RatingsEntry fetchByC_C_S_First(long classNameId, 793 long classPK, double score, 794 OrderByComparator<RatingsEntry> orderByComparator) { 795 return getPersistence() 796 .fetchByC_C_S_First(classNameId, classPK, score, 797 orderByComparator); 798 } 799 800 /** 801 * Returns the last ratings entry in the ordered set where classNameId = ? and classPK = ? and score = ?. 802 * 803 * @param classNameId the class name ID 804 * @param classPK the class p k 805 * @param score the score 806 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 807 * @return the last matching ratings entry 808 * @throws NoSuchEntryException if a matching ratings entry could not be found 809 */ 810 public static RatingsEntry findByC_C_S_Last(long classNameId, long classPK, 811 double score, OrderByComparator<RatingsEntry> orderByComparator) 812 throws com.liferay.portlet.ratings.exception.NoSuchEntryException { 813 return getPersistence() 814 .findByC_C_S_Last(classNameId, classPK, score, 815 orderByComparator); 816 } 817 818 /** 819 * Returns the last ratings entry in the ordered set where classNameId = ? and classPK = ? and score = ?. 820 * 821 * @param classNameId the class name ID 822 * @param classPK the class p k 823 * @param score the score 824 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 825 * @return the last matching ratings entry, or <code>null</code> if a matching ratings entry could not be found 826 */ 827 public static RatingsEntry fetchByC_C_S_Last(long classNameId, 828 long classPK, double score, 829 OrderByComparator<RatingsEntry> orderByComparator) { 830 return getPersistence() 831 .fetchByC_C_S_Last(classNameId, classPK, score, 832 orderByComparator); 833 } 834 835 /** 836 * Returns the ratings entries before and after the current ratings entry in the ordered set where classNameId = ? and classPK = ? and score = ?. 837 * 838 * @param entryId the primary key of the current ratings entry 839 * @param classNameId the class name ID 840 * @param classPK the class p k 841 * @param score the score 842 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 843 * @return the previous, current, and next ratings entry 844 * @throws NoSuchEntryException if a ratings entry with the primary key could not be found 845 */ 846 public static RatingsEntry[] findByC_C_S_PrevAndNext(long entryId, 847 long classNameId, long classPK, double score, 848 OrderByComparator<RatingsEntry> orderByComparator) 849 throws com.liferay.portlet.ratings.exception.NoSuchEntryException { 850 return getPersistence() 851 .findByC_C_S_PrevAndNext(entryId, classNameId, classPK, 852 score, orderByComparator); 853 } 854 855 /** 856 * Removes all the ratings entries where classNameId = ? and classPK = ? and score = ? from the database. 857 * 858 * @param classNameId the class name ID 859 * @param classPK the class p k 860 * @param score the score 861 */ 862 public static void removeByC_C_S(long classNameId, long classPK, 863 double score) { 864 getPersistence().removeByC_C_S(classNameId, classPK, score); 865 } 866 867 /** 868 * Returns the number of ratings entries where classNameId = ? and classPK = ? and score = ?. 869 * 870 * @param classNameId the class name ID 871 * @param classPK the class p k 872 * @param score the score 873 * @return the number of matching ratings entries 874 */ 875 public static int countByC_C_S(long classNameId, long classPK, double score) { 876 return getPersistence().countByC_C_S(classNameId, classPK, score); 877 } 878 879 /** 880 * Caches the ratings entry in the entity cache if it is enabled. 881 * 882 * @param ratingsEntry the ratings entry 883 */ 884 public static void cacheResult(RatingsEntry ratingsEntry) { 885 getPersistence().cacheResult(ratingsEntry); 886 } 887 888 /** 889 * Caches the ratings entries in the entity cache if it is enabled. 890 * 891 * @param ratingsEntries the ratings entries 892 */ 893 public static void cacheResult(List<RatingsEntry> ratingsEntries) { 894 getPersistence().cacheResult(ratingsEntries); 895 } 896 897 /** 898 * Creates a new ratings entry with the primary key. Does not add the ratings entry to the database. 899 * 900 * @param entryId the primary key for the new ratings entry 901 * @return the new ratings entry 902 */ 903 public static RatingsEntry create(long entryId) { 904 return getPersistence().create(entryId); 905 } 906 907 /** 908 * Removes the ratings entry with the primary key from the database. Also notifies the appropriate model listeners. 909 * 910 * @param entryId the primary key of the ratings entry 911 * @return the ratings entry that was removed 912 * @throws NoSuchEntryException if a ratings entry with the primary key could not be found 913 */ 914 public static RatingsEntry remove(long entryId) 915 throws com.liferay.portlet.ratings.exception.NoSuchEntryException { 916 return getPersistence().remove(entryId); 917 } 918 919 public static RatingsEntry updateImpl(RatingsEntry ratingsEntry) { 920 return getPersistence().updateImpl(ratingsEntry); 921 } 922 923 /** 924 * Returns the ratings entry with the primary key or throws a {@link NoSuchEntryException} if it could not be found. 925 * 926 * @param entryId the primary key of the ratings entry 927 * @return the ratings entry 928 * @throws NoSuchEntryException if a ratings entry with the primary key could not be found 929 */ 930 public static RatingsEntry findByPrimaryKey(long entryId) 931 throws com.liferay.portlet.ratings.exception.NoSuchEntryException { 932 return getPersistence().findByPrimaryKey(entryId); 933 } 934 935 /** 936 * Returns the ratings entry with the primary key or returns <code>null</code> if it could not be found. 937 * 938 * @param entryId the primary key of the ratings entry 939 * @return the ratings entry, or <code>null</code> if a ratings entry with the primary key could not be found 940 */ 941 public static RatingsEntry fetchByPrimaryKey(long entryId) { 942 return getPersistence().fetchByPrimaryKey(entryId); 943 } 944 945 public static java.util.Map<java.io.Serializable, RatingsEntry> fetchByPrimaryKeys( 946 java.util.Set<java.io.Serializable> primaryKeys) { 947 return getPersistence().fetchByPrimaryKeys(primaryKeys); 948 } 949 950 /** 951 * Returns all the ratings entries. 952 * 953 * @return the ratings entries 954 */ 955 public static List<RatingsEntry> findAll() { 956 return getPersistence().findAll(); 957 } 958 959 /** 960 * Returns a range of all the ratings entries. 961 * 962 * <p> 963 * 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. 964 * </p> 965 * 966 * @param start the lower bound of the range of ratings entries 967 * @param end the upper bound of the range of ratings entries (not inclusive) 968 * @return the range of ratings entries 969 */ 970 public static List<RatingsEntry> findAll(int start, int end) { 971 return getPersistence().findAll(start, end); 972 } 973 974 /** 975 * Returns an ordered range of all the ratings entries. 976 * 977 * <p> 978 * 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. 979 * </p> 980 * 981 * @param start the lower bound of the range of ratings entries 982 * @param end the upper bound of the range of ratings entries (not inclusive) 983 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 984 * @return the ordered range of ratings entries 985 */ 986 public static List<RatingsEntry> findAll(int start, int end, 987 OrderByComparator<RatingsEntry> orderByComparator) { 988 return getPersistence().findAll(start, end, orderByComparator); 989 } 990 991 /** 992 * Returns an ordered range of all the ratings entries. 993 * 994 * <p> 995 * 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. 996 * </p> 997 * 998 * @param start the lower bound of the range of ratings entries 999 * @param end the upper bound of the range of ratings entries (not inclusive) 1000 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1001 * @param retrieveFromCache whether to retrieve from the finder cache 1002 * @return the ordered range of ratings entries 1003 */ 1004 public static List<RatingsEntry> findAll(int start, int end, 1005 OrderByComparator<RatingsEntry> orderByComparator, 1006 boolean retrieveFromCache) { 1007 return getPersistence() 1008 .findAll(start, end, orderByComparator, retrieveFromCache); 1009 } 1010 1011 /** 1012 * Removes all the ratings entries from the database. 1013 */ 1014 public static void removeAll() { 1015 getPersistence().removeAll(); 1016 } 1017 1018 /** 1019 * Returns the number of ratings entries. 1020 * 1021 * @return the number of ratings entries 1022 */ 1023 public static int countAll() { 1024 return getPersistence().countAll(); 1025 } 1026 1027 public static java.util.Set<java.lang.String> getBadColumnNames() { 1028 return getPersistence().getBadColumnNames(); 1029 } 1030 1031 public static RatingsEntryPersistence getPersistence() { 1032 if (_persistence == null) { 1033 _persistence = (RatingsEntryPersistence)PortalBeanLocatorUtil.locate(RatingsEntryPersistence.class.getName()); 1034 1035 ReferenceRegistry.registerReference(RatingsEntryUtil.class, 1036 "_persistence"); 1037 } 1038 1039 return _persistence; 1040 } 1041 1042 private static RatingsEntryPersistence _persistence; 1043 }