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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63; 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 = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63; 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 = &#63; and companyId = &#63;.
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 = &#63; and classPK = &#63;.
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 = &#63; and classPK = &#63;.
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 = &#63; and classPK = &#63;.
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 = &#63; and classPK = &#63;.
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 = &#63; and classPK = &#63;.
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 = &#63; and classPK = &#63;.
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 = &#63; and classPK = &#63;.
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 = &#63; and classPK = &#63;.
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 = &#63; and classPK = &#63;.
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 = &#63; and classPK = &#63; 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 = &#63; and classPK = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; 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 = &#63; and classNameId = &#63; and classPK = &#63; 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 = &#63; and classNameId = &#63; and classPK = &#63; 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 = &#63; and classNameId = &#63; and classPK = &#63; 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 = &#63; and classNameId = &#63; and classPK = &#63;.
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 = &#63; and classPK = &#63; and score = &#63;.
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 = &#63; and classPK = &#63; and score = &#63;.
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 = &#63; and classPK = &#63; and score = &#63;.
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 = &#63; and classPK = &#63; and score = &#63;.
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 = &#63; and classPK = &#63; and score = &#63;.
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 = &#63; and classPK = &#63; and score = &#63;.
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 = &#63; and classPK = &#63; and score = &#63;.
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 = &#63; and classPK = &#63; and score = &#63;.
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 = &#63; and classPK = &#63; and score = &#63;.
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 = &#63; and classPK = &#63; and score = &#63; 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 = &#63; and classPK = &#63; and score = &#63;.
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    }