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.portal.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.model.Website;
024    import com.liferay.portal.service.ServiceContext;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the website service. This utility wraps {@link com.liferay.portal.service.persistence.impl.WebsitePersistenceImpl} 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.
030     *
031     * <p>
032     * Caching information and settings can be found in <code>portal.properties</code>
033     * </p>
034     *
035     * @author Brian Wing Shun Chan
036     * @see WebsitePersistence
037     * @see com.liferay.portal.service.persistence.impl.WebsitePersistenceImpl
038     * @generated
039     */
040    @ProviderType
041    public class WebsiteUtil {
042            /*
043             * NOTE FOR DEVELOPERS:
044             *
045             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
046             */
047    
048            /**
049             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
050             */
051            public static void clearCache() {
052                    getPersistence().clearCache();
053            }
054    
055            /**
056             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
057             */
058            public static void clearCache(Website website) {
059                    getPersistence().clearCache(website);
060            }
061    
062            /**
063             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
064             */
065            public static long countWithDynamicQuery(DynamicQuery dynamicQuery) {
066                    return getPersistence().countWithDynamicQuery(dynamicQuery);
067            }
068    
069            /**
070             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
071             */
072            public static List<Website> findWithDynamicQuery(DynamicQuery dynamicQuery) {
073                    return getPersistence().findWithDynamicQuery(dynamicQuery);
074            }
075    
076            /**
077             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
078             */
079            public static List<Website> findWithDynamicQuery(
080                    DynamicQuery dynamicQuery, int start, int end) {
081                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
082            }
083    
084            /**
085             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
086             */
087            public static List<Website> findWithDynamicQuery(
088                    DynamicQuery dynamicQuery, int start, int end,
089                    OrderByComparator<Website> orderByComparator) {
090                    return getPersistence()
091                                       .findWithDynamicQuery(dynamicQuery, start, end,
092                            orderByComparator);
093            }
094    
095            /**
096             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
097             */
098            public static Website update(Website website) {
099                    return getPersistence().update(website);
100            }
101    
102            /**
103             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
104             */
105            public static Website update(Website website, ServiceContext serviceContext) {
106                    return getPersistence().update(website, serviceContext);
107            }
108    
109            /**
110            * Returns all the websites where uuid = &#63;.
111            *
112            * @param uuid the uuid
113            * @return the matching websites
114            */
115            public static List<Website> findByUuid(java.lang.String uuid) {
116                    return getPersistence().findByUuid(uuid);
117            }
118    
119            /**
120            * Returns a range of all the websites where uuid = &#63;.
121            *
122            * <p>
123            * 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 WebsiteModelImpl}. 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.
124            * </p>
125            *
126            * @param uuid the uuid
127            * @param start the lower bound of the range of websites
128            * @param end the upper bound of the range of websites (not inclusive)
129            * @return the range of matching websites
130            */
131            public static List<Website> findByUuid(java.lang.String uuid, int start,
132                    int end) {
133                    return getPersistence().findByUuid(uuid, start, end);
134            }
135    
136            /**
137            * Returns an ordered range of all the websites where uuid = &#63;.
138            *
139            * <p>
140            * 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 WebsiteModelImpl}. 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.
141            * </p>
142            *
143            * @param uuid the uuid
144            * @param start the lower bound of the range of websites
145            * @param end the upper bound of the range of websites (not inclusive)
146            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
147            * @return the ordered range of matching websites
148            */
149            public static List<Website> findByUuid(java.lang.String uuid, int start,
150                    int end, OrderByComparator<Website> orderByComparator) {
151                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
152            }
153    
154            /**
155            * Returns an ordered range of all the websites where uuid = &#63;.
156            *
157            * <p>
158            * 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 WebsiteModelImpl}. 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.
159            * </p>
160            *
161            * @param uuid the uuid
162            * @param start the lower bound of the range of websites
163            * @param end the upper bound of the range of websites (not inclusive)
164            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
165            * @param retrieveFromCache whether to retrieve from the finder cache
166            * @return the ordered range of matching websites
167            */
168            public static List<Website> findByUuid(java.lang.String uuid, int start,
169                    int end, OrderByComparator<Website> orderByComparator,
170                    boolean retrieveFromCache) {
171                    return getPersistence()
172                                       .findByUuid(uuid, start, end, orderByComparator,
173                            retrieveFromCache);
174            }
175    
176            /**
177            * Returns the first website in the ordered set where uuid = &#63;.
178            *
179            * @param uuid the uuid
180            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
181            * @return the first matching website
182            * @throws NoSuchWebsiteException if a matching website could not be found
183            */
184            public static Website findByUuid_First(java.lang.String uuid,
185                    OrderByComparator<Website> orderByComparator)
186                    throws com.liferay.portal.exception.NoSuchWebsiteException {
187                    return getPersistence().findByUuid_First(uuid, orderByComparator);
188            }
189    
190            /**
191            * Returns the first website in the ordered set where uuid = &#63;.
192            *
193            * @param uuid the uuid
194            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
195            * @return the first matching website, or <code>null</code> if a matching website could not be found
196            */
197            public static Website fetchByUuid_First(java.lang.String uuid,
198                    OrderByComparator<Website> orderByComparator) {
199                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
200            }
201    
202            /**
203            * Returns the last website in the ordered set where uuid = &#63;.
204            *
205            * @param uuid the uuid
206            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
207            * @return the last matching website
208            * @throws NoSuchWebsiteException if a matching website could not be found
209            */
210            public static Website findByUuid_Last(java.lang.String uuid,
211                    OrderByComparator<Website> orderByComparator)
212                    throws com.liferay.portal.exception.NoSuchWebsiteException {
213                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
214            }
215    
216            /**
217            * Returns the last website in the ordered set where uuid = &#63;.
218            *
219            * @param uuid the uuid
220            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
221            * @return the last matching website, or <code>null</code> if a matching website could not be found
222            */
223            public static Website fetchByUuid_Last(java.lang.String uuid,
224                    OrderByComparator<Website> orderByComparator) {
225                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
226            }
227    
228            /**
229            * Returns the websites before and after the current website in the ordered set where uuid = &#63;.
230            *
231            * @param websiteId the primary key of the current website
232            * @param uuid the uuid
233            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
234            * @return the previous, current, and next website
235            * @throws NoSuchWebsiteException if a website with the primary key could not be found
236            */
237            public static Website[] findByUuid_PrevAndNext(long websiteId,
238                    java.lang.String uuid, OrderByComparator<Website> orderByComparator)
239                    throws com.liferay.portal.exception.NoSuchWebsiteException {
240                    return getPersistence()
241                                       .findByUuid_PrevAndNext(websiteId, uuid, orderByComparator);
242            }
243    
244            /**
245            * Removes all the websites where uuid = &#63; from the database.
246            *
247            * @param uuid the uuid
248            */
249            public static void removeByUuid(java.lang.String uuid) {
250                    getPersistence().removeByUuid(uuid);
251            }
252    
253            /**
254            * Returns the number of websites where uuid = &#63;.
255            *
256            * @param uuid the uuid
257            * @return the number of matching websites
258            */
259            public static int countByUuid(java.lang.String uuid) {
260                    return getPersistence().countByUuid(uuid);
261            }
262    
263            /**
264            * Returns all the websites where uuid = &#63; and companyId = &#63;.
265            *
266            * @param uuid the uuid
267            * @param companyId the company ID
268            * @return the matching websites
269            */
270            public static List<Website> findByUuid_C(java.lang.String uuid,
271                    long companyId) {
272                    return getPersistence().findByUuid_C(uuid, companyId);
273            }
274    
275            /**
276            * Returns a range of all the websites where uuid = &#63; and companyId = &#63;.
277            *
278            * <p>
279            * 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 WebsiteModelImpl}. 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.
280            * </p>
281            *
282            * @param uuid the uuid
283            * @param companyId the company ID
284            * @param start the lower bound of the range of websites
285            * @param end the upper bound of the range of websites (not inclusive)
286            * @return the range of matching websites
287            */
288            public static List<Website> findByUuid_C(java.lang.String uuid,
289                    long companyId, int start, int end) {
290                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
291            }
292    
293            /**
294            * Returns an ordered range of all the websites where uuid = &#63; and companyId = &#63;.
295            *
296            * <p>
297            * 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 WebsiteModelImpl}. 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.
298            * </p>
299            *
300            * @param uuid the uuid
301            * @param companyId the company ID
302            * @param start the lower bound of the range of websites
303            * @param end the upper bound of the range of websites (not inclusive)
304            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
305            * @return the ordered range of matching websites
306            */
307            public static List<Website> findByUuid_C(java.lang.String uuid,
308                    long companyId, int start, int end,
309                    OrderByComparator<Website> orderByComparator) {
310                    return getPersistence()
311                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
312            }
313    
314            /**
315            * Returns an ordered range of all the websites where uuid = &#63; and companyId = &#63;.
316            *
317            * <p>
318            * 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 WebsiteModelImpl}. 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.
319            * </p>
320            *
321            * @param uuid the uuid
322            * @param companyId the company ID
323            * @param start the lower bound of the range of websites
324            * @param end the upper bound of the range of websites (not inclusive)
325            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
326            * @param retrieveFromCache whether to retrieve from the finder cache
327            * @return the ordered range of matching websites
328            */
329            public static List<Website> findByUuid_C(java.lang.String uuid,
330                    long companyId, int start, int end,
331                    OrderByComparator<Website> orderByComparator, boolean retrieveFromCache) {
332                    return getPersistence()
333                                       .findByUuid_C(uuid, companyId, start, end,
334                            orderByComparator, retrieveFromCache);
335            }
336    
337            /**
338            * Returns the first website in the ordered set where uuid = &#63; and companyId = &#63;.
339            *
340            * @param uuid the uuid
341            * @param companyId the company ID
342            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
343            * @return the first matching website
344            * @throws NoSuchWebsiteException if a matching website could not be found
345            */
346            public static Website findByUuid_C_First(java.lang.String uuid,
347                    long companyId, OrderByComparator<Website> orderByComparator)
348                    throws com.liferay.portal.exception.NoSuchWebsiteException {
349                    return getPersistence()
350                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
351            }
352    
353            /**
354            * Returns the first website in the ordered set where uuid = &#63; and companyId = &#63;.
355            *
356            * @param uuid the uuid
357            * @param companyId the company ID
358            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
359            * @return the first matching website, or <code>null</code> if a matching website could not be found
360            */
361            public static Website fetchByUuid_C_First(java.lang.String uuid,
362                    long companyId, OrderByComparator<Website> orderByComparator) {
363                    return getPersistence()
364                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
365            }
366    
367            /**
368            * Returns the last website in the ordered set where uuid = &#63; and companyId = &#63;.
369            *
370            * @param uuid the uuid
371            * @param companyId the company ID
372            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
373            * @return the last matching website
374            * @throws NoSuchWebsiteException if a matching website could not be found
375            */
376            public static Website findByUuid_C_Last(java.lang.String uuid,
377                    long companyId, OrderByComparator<Website> orderByComparator)
378                    throws com.liferay.portal.exception.NoSuchWebsiteException {
379                    return getPersistence()
380                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
381            }
382    
383            /**
384            * Returns the last website in the ordered set where uuid = &#63; and companyId = &#63;.
385            *
386            * @param uuid the uuid
387            * @param companyId the company ID
388            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
389            * @return the last matching website, or <code>null</code> if a matching website could not be found
390            */
391            public static Website fetchByUuid_C_Last(java.lang.String uuid,
392                    long companyId, OrderByComparator<Website> orderByComparator) {
393                    return getPersistence()
394                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
395            }
396    
397            /**
398            * Returns the websites before and after the current website in the ordered set where uuid = &#63; and companyId = &#63;.
399            *
400            * @param websiteId the primary key of the current website
401            * @param uuid the uuid
402            * @param companyId the company ID
403            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
404            * @return the previous, current, and next website
405            * @throws NoSuchWebsiteException if a website with the primary key could not be found
406            */
407            public static Website[] findByUuid_C_PrevAndNext(long websiteId,
408                    java.lang.String uuid, long companyId,
409                    OrderByComparator<Website> orderByComparator)
410                    throws com.liferay.portal.exception.NoSuchWebsiteException {
411                    return getPersistence()
412                                       .findByUuid_C_PrevAndNext(websiteId, uuid, companyId,
413                            orderByComparator);
414            }
415    
416            /**
417            * Removes all the websites where uuid = &#63; and companyId = &#63; from the database.
418            *
419            * @param uuid the uuid
420            * @param companyId the company ID
421            */
422            public static void removeByUuid_C(java.lang.String uuid, long companyId) {
423                    getPersistence().removeByUuid_C(uuid, companyId);
424            }
425    
426            /**
427            * Returns the number of websites where uuid = &#63; and companyId = &#63;.
428            *
429            * @param uuid the uuid
430            * @param companyId the company ID
431            * @return the number of matching websites
432            */
433            public static int countByUuid_C(java.lang.String uuid, long companyId) {
434                    return getPersistence().countByUuid_C(uuid, companyId);
435            }
436    
437            /**
438            * Returns all the websites where companyId = &#63;.
439            *
440            * @param companyId the company ID
441            * @return the matching websites
442            */
443            public static List<Website> findByCompanyId(long companyId) {
444                    return getPersistence().findByCompanyId(companyId);
445            }
446    
447            /**
448            * Returns a range of all the websites where companyId = &#63;.
449            *
450            * <p>
451            * 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 WebsiteModelImpl}. 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.
452            * </p>
453            *
454            * @param companyId the company ID
455            * @param start the lower bound of the range of websites
456            * @param end the upper bound of the range of websites (not inclusive)
457            * @return the range of matching websites
458            */
459            public static List<Website> findByCompanyId(long companyId, int start,
460                    int end) {
461                    return getPersistence().findByCompanyId(companyId, start, end);
462            }
463    
464            /**
465            * Returns an ordered range of all the websites where companyId = &#63;.
466            *
467            * <p>
468            * 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 WebsiteModelImpl}. 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.
469            * </p>
470            *
471            * @param companyId the company ID
472            * @param start the lower bound of the range of websites
473            * @param end the upper bound of the range of websites (not inclusive)
474            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
475            * @return the ordered range of matching websites
476            */
477            public static List<Website> findByCompanyId(long companyId, int start,
478                    int end, OrderByComparator<Website> orderByComparator) {
479                    return getPersistence()
480                                       .findByCompanyId(companyId, start, end, orderByComparator);
481            }
482    
483            /**
484            * Returns an ordered range of all the websites where companyId = &#63;.
485            *
486            * <p>
487            * 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 WebsiteModelImpl}. 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.
488            * </p>
489            *
490            * @param companyId the company ID
491            * @param start the lower bound of the range of websites
492            * @param end the upper bound of the range of websites (not inclusive)
493            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
494            * @param retrieveFromCache whether to retrieve from the finder cache
495            * @return the ordered range of matching websites
496            */
497            public static List<Website> findByCompanyId(long companyId, int start,
498                    int end, OrderByComparator<Website> orderByComparator,
499                    boolean retrieveFromCache) {
500                    return getPersistence()
501                                       .findByCompanyId(companyId, start, end, orderByComparator,
502                            retrieveFromCache);
503            }
504    
505            /**
506            * Returns the first website in the ordered set where companyId = &#63;.
507            *
508            * @param companyId the company ID
509            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
510            * @return the first matching website
511            * @throws NoSuchWebsiteException if a matching website could not be found
512            */
513            public static Website findByCompanyId_First(long companyId,
514                    OrderByComparator<Website> orderByComparator)
515                    throws com.liferay.portal.exception.NoSuchWebsiteException {
516                    return getPersistence()
517                                       .findByCompanyId_First(companyId, orderByComparator);
518            }
519    
520            /**
521            * Returns the first website in the ordered set where companyId = &#63;.
522            *
523            * @param companyId the company ID
524            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
525            * @return the first matching website, or <code>null</code> if a matching website could not be found
526            */
527            public static Website fetchByCompanyId_First(long companyId,
528                    OrderByComparator<Website> orderByComparator) {
529                    return getPersistence()
530                                       .fetchByCompanyId_First(companyId, orderByComparator);
531            }
532    
533            /**
534            * Returns the last website in the ordered set where companyId = &#63;.
535            *
536            * @param companyId the company ID
537            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
538            * @return the last matching website
539            * @throws NoSuchWebsiteException if a matching website could not be found
540            */
541            public static Website findByCompanyId_Last(long companyId,
542                    OrderByComparator<Website> orderByComparator)
543                    throws com.liferay.portal.exception.NoSuchWebsiteException {
544                    return getPersistence()
545                                       .findByCompanyId_Last(companyId, orderByComparator);
546            }
547    
548            /**
549            * Returns the last website in the ordered set where companyId = &#63;.
550            *
551            * @param companyId the company ID
552            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
553            * @return the last matching website, or <code>null</code> if a matching website could not be found
554            */
555            public static Website fetchByCompanyId_Last(long companyId,
556                    OrderByComparator<Website> orderByComparator) {
557                    return getPersistence()
558                                       .fetchByCompanyId_Last(companyId, orderByComparator);
559            }
560    
561            /**
562            * Returns the websites before and after the current website in the ordered set where companyId = &#63;.
563            *
564            * @param websiteId the primary key of the current website
565            * @param companyId the company ID
566            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
567            * @return the previous, current, and next website
568            * @throws NoSuchWebsiteException if a website with the primary key could not be found
569            */
570            public static Website[] findByCompanyId_PrevAndNext(long websiteId,
571                    long companyId, OrderByComparator<Website> orderByComparator)
572                    throws com.liferay.portal.exception.NoSuchWebsiteException {
573                    return getPersistence()
574                                       .findByCompanyId_PrevAndNext(websiteId, companyId,
575                            orderByComparator);
576            }
577    
578            /**
579            * Removes all the websites where companyId = &#63; from the database.
580            *
581            * @param companyId the company ID
582            */
583            public static void removeByCompanyId(long companyId) {
584                    getPersistence().removeByCompanyId(companyId);
585            }
586    
587            /**
588            * Returns the number of websites where companyId = &#63;.
589            *
590            * @param companyId the company ID
591            * @return the number of matching websites
592            */
593            public static int countByCompanyId(long companyId) {
594                    return getPersistence().countByCompanyId(companyId);
595            }
596    
597            /**
598            * Returns all the websites where userId = &#63;.
599            *
600            * @param userId the user ID
601            * @return the matching websites
602            */
603            public static List<Website> findByUserId(long userId) {
604                    return getPersistence().findByUserId(userId);
605            }
606    
607            /**
608            * Returns a range of all the websites where userId = &#63;.
609            *
610            * <p>
611            * 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 WebsiteModelImpl}. 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.
612            * </p>
613            *
614            * @param userId the user ID
615            * @param start the lower bound of the range of websites
616            * @param end the upper bound of the range of websites (not inclusive)
617            * @return the range of matching websites
618            */
619            public static List<Website> findByUserId(long userId, int start, int end) {
620                    return getPersistence().findByUserId(userId, start, end);
621            }
622    
623            /**
624            * Returns an ordered range of all the websites where userId = &#63;.
625            *
626            * <p>
627            * 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 WebsiteModelImpl}. 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.
628            * </p>
629            *
630            * @param userId the user ID
631            * @param start the lower bound of the range of websites
632            * @param end the upper bound of the range of websites (not inclusive)
633            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
634            * @return the ordered range of matching websites
635            */
636            public static List<Website> findByUserId(long userId, int start, int end,
637                    OrderByComparator<Website> orderByComparator) {
638                    return getPersistence()
639                                       .findByUserId(userId, start, end, orderByComparator);
640            }
641    
642            /**
643            * Returns an ordered range of all the websites where userId = &#63;.
644            *
645            * <p>
646            * 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 WebsiteModelImpl}. 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.
647            * </p>
648            *
649            * @param userId the user ID
650            * @param start the lower bound of the range of websites
651            * @param end the upper bound of the range of websites (not inclusive)
652            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
653            * @param retrieveFromCache whether to retrieve from the finder cache
654            * @return the ordered range of matching websites
655            */
656            public static List<Website> findByUserId(long userId, int start, int end,
657                    OrderByComparator<Website> orderByComparator, boolean retrieveFromCache) {
658                    return getPersistence()
659                                       .findByUserId(userId, start, end, orderByComparator,
660                            retrieveFromCache);
661            }
662    
663            /**
664            * Returns the first website in the ordered set where userId = &#63;.
665            *
666            * @param userId the user ID
667            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
668            * @return the first matching website
669            * @throws NoSuchWebsiteException if a matching website could not be found
670            */
671            public static Website findByUserId_First(long userId,
672                    OrderByComparator<Website> orderByComparator)
673                    throws com.liferay.portal.exception.NoSuchWebsiteException {
674                    return getPersistence().findByUserId_First(userId, orderByComparator);
675            }
676    
677            /**
678            * Returns the first website in the ordered set where userId = &#63;.
679            *
680            * @param userId the user ID
681            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
682            * @return the first matching website, or <code>null</code> if a matching website could not be found
683            */
684            public static Website fetchByUserId_First(long userId,
685                    OrderByComparator<Website> orderByComparator) {
686                    return getPersistence().fetchByUserId_First(userId, orderByComparator);
687            }
688    
689            /**
690            * Returns the last website in the ordered set where userId = &#63;.
691            *
692            * @param userId the user ID
693            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
694            * @return the last matching website
695            * @throws NoSuchWebsiteException if a matching website could not be found
696            */
697            public static Website findByUserId_Last(long userId,
698                    OrderByComparator<Website> orderByComparator)
699                    throws com.liferay.portal.exception.NoSuchWebsiteException {
700                    return getPersistence().findByUserId_Last(userId, orderByComparator);
701            }
702    
703            /**
704            * Returns the last website in the ordered set where userId = &#63;.
705            *
706            * @param userId the user ID
707            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
708            * @return the last matching website, or <code>null</code> if a matching website could not be found
709            */
710            public static Website fetchByUserId_Last(long userId,
711                    OrderByComparator<Website> orderByComparator) {
712                    return getPersistence().fetchByUserId_Last(userId, orderByComparator);
713            }
714    
715            /**
716            * Returns the websites before and after the current website in the ordered set where userId = &#63;.
717            *
718            * @param websiteId the primary key of the current website
719            * @param userId the user ID
720            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
721            * @return the previous, current, and next website
722            * @throws NoSuchWebsiteException if a website with the primary key could not be found
723            */
724            public static Website[] findByUserId_PrevAndNext(long websiteId,
725                    long userId, OrderByComparator<Website> orderByComparator)
726                    throws com.liferay.portal.exception.NoSuchWebsiteException {
727                    return getPersistence()
728                                       .findByUserId_PrevAndNext(websiteId, userId,
729                            orderByComparator);
730            }
731    
732            /**
733            * Removes all the websites where userId = &#63; from the database.
734            *
735            * @param userId the user ID
736            */
737            public static void removeByUserId(long userId) {
738                    getPersistence().removeByUserId(userId);
739            }
740    
741            /**
742            * Returns the number of websites where userId = &#63;.
743            *
744            * @param userId the user ID
745            * @return the number of matching websites
746            */
747            public static int countByUserId(long userId) {
748                    return getPersistence().countByUserId(userId);
749            }
750    
751            /**
752            * Returns all the websites where companyId = &#63; and classNameId = &#63;.
753            *
754            * @param companyId the company ID
755            * @param classNameId the class name ID
756            * @return the matching websites
757            */
758            public static List<Website> findByC_C(long companyId, long classNameId) {
759                    return getPersistence().findByC_C(companyId, classNameId);
760            }
761    
762            /**
763            * Returns a range of all the websites where companyId = &#63; and classNameId = &#63;.
764            *
765            * <p>
766            * 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 WebsiteModelImpl}. 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.
767            * </p>
768            *
769            * @param companyId the company ID
770            * @param classNameId the class name ID
771            * @param start the lower bound of the range of websites
772            * @param end the upper bound of the range of websites (not inclusive)
773            * @return the range of matching websites
774            */
775            public static List<Website> findByC_C(long companyId, long classNameId,
776                    int start, int end) {
777                    return getPersistence().findByC_C(companyId, classNameId, start, end);
778            }
779    
780            /**
781            * Returns an ordered range of all the websites where companyId = &#63; and classNameId = &#63;.
782            *
783            * <p>
784            * 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 WebsiteModelImpl}. 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.
785            * </p>
786            *
787            * @param companyId the company ID
788            * @param classNameId the class name ID
789            * @param start the lower bound of the range of websites
790            * @param end the upper bound of the range of websites (not inclusive)
791            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
792            * @return the ordered range of matching websites
793            */
794            public static List<Website> findByC_C(long companyId, long classNameId,
795                    int start, int end, OrderByComparator<Website> orderByComparator) {
796                    return getPersistence()
797                                       .findByC_C(companyId, classNameId, start, end,
798                            orderByComparator);
799            }
800    
801            /**
802            * Returns an ordered range of all the websites where companyId = &#63; and classNameId = &#63;.
803            *
804            * <p>
805            * 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 WebsiteModelImpl}. 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.
806            * </p>
807            *
808            * @param companyId the company ID
809            * @param classNameId the class name ID
810            * @param start the lower bound of the range of websites
811            * @param end the upper bound of the range of websites (not inclusive)
812            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
813            * @param retrieveFromCache whether to retrieve from the finder cache
814            * @return the ordered range of matching websites
815            */
816            public static List<Website> findByC_C(long companyId, long classNameId,
817                    int start, int end, OrderByComparator<Website> orderByComparator,
818                    boolean retrieveFromCache) {
819                    return getPersistence()
820                                       .findByC_C(companyId, classNameId, start, end,
821                            orderByComparator, retrieveFromCache);
822            }
823    
824            /**
825            * Returns the first website in the ordered set where companyId = &#63; and classNameId = &#63;.
826            *
827            * @param companyId the company ID
828            * @param classNameId the class name ID
829            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
830            * @return the first matching website
831            * @throws NoSuchWebsiteException if a matching website could not be found
832            */
833            public static Website findByC_C_First(long companyId, long classNameId,
834                    OrderByComparator<Website> orderByComparator)
835                    throws com.liferay.portal.exception.NoSuchWebsiteException {
836                    return getPersistence()
837                                       .findByC_C_First(companyId, classNameId, orderByComparator);
838            }
839    
840            /**
841            * Returns the first website in the ordered set where companyId = &#63; and classNameId = &#63;.
842            *
843            * @param companyId the company ID
844            * @param classNameId the class name ID
845            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
846            * @return the first matching website, or <code>null</code> if a matching website could not be found
847            */
848            public static Website fetchByC_C_First(long companyId, long classNameId,
849                    OrderByComparator<Website> orderByComparator) {
850                    return getPersistence()
851                                       .fetchByC_C_First(companyId, classNameId, orderByComparator);
852            }
853    
854            /**
855            * Returns the last website in the ordered set where companyId = &#63; and classNameId = &#63;.
856            *
857            * @param companyId the company ID
858            * @param classNameId the class name ID
859            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
860            * @return the last matching website
861            * @throws NoSuchWebsiteException if a matching website could not be found
862            */
863            public static Website findByC_C_Last(long companyId, long classNameId,
864                    OrderByComparator<Website> orderByComparator)
865                    throws com.liferay.portal.exception.NoSuchWebsiteException {
866                    return getPersistence()
867                                       .findByC_C_Last(companyId, classNameId, orderByComparator);
868            }
869    
870            /**
871            * Returns the last website in the ordered set where companyId = &#63; and classNameId = &#63;.
872            *
873            * @param companyId the company ID
874            * @param classNameId the class name ID
875            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
876            * @return the last matching website, or <code>null</code> if a matching website could not be found
877            */
878            public static Website fetchByC_C_Last(long companyId, long classNameId,
879                    OrderByComparator<Website> orderByComparator) {
880                    return getPersistence()
881                                       .fetchByC_C_Last(companyId, classNameId, orderByComparator);
882            }
883    
884            /**
885            * Returns the websites before and after the current website in the ordered set where companyId = &#63; and classNameId = &#63;.
886            *
887            * @param websiteId the primary key of the current website
888            * @param companyId the company ID
889            * @param classNameId the class name ID
890            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
891            * @return the previous, current, and next website
892            * @throws NoSuchWebsiteException if a website with the primary key could not be found
893            */
894            public static Website[] findByC_C_PrevAndNext(long websiteId,
895                    long companyId, long classNameId,
896                    OrderByComparator<Website> orderByComparator)
897                    throws com.liferay.portal.exception.NoSuchWebsiteException {
898                    return getPersistence()
899                                       .findByC_C_PrevAndNext(websiteId, companyId, classNameId,
900                            orderByComparator);
901            }
902    
903            /**
904            * Removes all the websites where companyId = &#63; and classNameId = &#63; from the database.
905            *
906            * @param companyId the company ID
907            * @param classNameId the class name ID
908            */
909            public static void removeByC_C(long companyId, long classNameId) {
910                    getPersistence().removeByC_C(companyId, classNameId);
911            }
912    
913            /**
914            * Returns the number of websites where companyId = &#63; and classNameId = &#63;.
915            *
916            * @param companyId the company ID
917            * @param classNameId the class name ID
918            * @return the number of matching websites
919            */
920            public static int countByC_C(long companyId, long classNameId) {
921                    return getPersistence().countByC_C(companyId, classNameId);
922            }
923    
924            /**
925            * Returns all the websites where companyId = &#63; and classNameId = &#63; and classPK = &#63;.
926            *
927            * @param companyId the company ID
928            * @param classNameId the class name ID
929            * @param classPK the class p k
930            * @return the matching websites
931            */
932            public static List<Website> findByC_C_C(long companyId, long classNameId,
933                    long classPK) {
934                    return getPersistence().findByC_C_C(companyId, classNameId, classPK);
935            }
936    
937            /**
938            * Returns a range of all the websites where companyId = &#63; and classNameId = &#63; and classPK = &#63;.
939            *
940            * <p>
941            * 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 WebsiteModelImpl}. 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.
942            * </p>
943            *
944            * @param companyId the company ID
945            * @param classNameId the class name ID
946            * @param classPK the class p k
947            * @param start the lower bound of the range of websites
948            * @param end the upper bound of the range of websites (not inclusive)
949            * @return the range of matching websites
950            */
951            public static List<Website> findByC_C_C(long companyId, long classNameId,
952                    long classPK, int start, int end) {
953                    return getPersistence()
954                                       .findByC_C_C(companyId, classNameId, classPK, start, end);
955            }
956    
957            /**
958            * Returns an ordered range of all the websites where companyId = &#63; and classNameId = &#63; and classPK = &#63;.
959            *
960            * <p>
961            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link WebsiteModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
962            * </p>
963            *
964            * @param companyId the company ID
965            * @param classNameId the class name ID
966            * @param classPK the class p k
967            * @param start the lower bound of the range of websites
968            * @param end the upper bound of the range of websites (not inclusive)
969            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
970            * @return the ordered range of matching websites
971            */
972            public static List<Website> findByC_C_C(long companyId, long classNameId,
973                    long classPK, int start, int end,
974                    OrderByComparator<Website> orderByComparator) {
975                    return getPersistence()
976                                       .findByC_C_C(companyId, classNameId, classPK, start, end,
977                            orderByComparator);
978            }
979    
980            /**
981            * Returns an ordered range of all the websites where companyId = &#63; and classNameId = &#63; and classPK = &#63;.
982            *
983            * <p>
984            * 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 WebsiteModelImpl}. 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.
985            * </p>
986            *
987            * @param companyId the company ID
988            * @param classNameId the class name ID
989            * @param classPK the class p k
990            * @param start the lower bound of the range of websites
991            * @param end the upper bound of the range of websites (not inclusive)
992            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
993            * @param retrieveFromCache whether to retrieve from the finder cache
994            * @return the ordered range of matching websites
995            */
996            public static List<Website> findByC_C_C(long companyId, long classNameId,
997                    long classPK, int start, int end,
998                    OrderByComparator<Website> orderByComparator, boolean retrieveFromCache) {
999                    return getPersistence()
1000                                       .findByC_C_C(companyId, classNameId, classPK, start, end,
1001                            orderByComparator, retrieveFromCache);
1002            }
1003    
1004            /**
1005            * Returns the first website in the ordered set where companyId = &#63; and classNameId = &#63; and classPK = &#63;.
1006            *
1007            * @param companyId the company ID
1008            * @param classNameId the class name ID
1009            * @param classPK the class p k
1010            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1011            * @return the first matching website
1012            * @throws NoSuchWebsiteException if a matching website could not be found
1013            */
1014            public static Website findByC_C_C_First(long companyId, long classNameId,
1015                    long classPK, OrderByComparator<Website> orderByComparator)
1016                    throws com.liferay.portal.exception.NoSuchWebsiteException {
1017                    return getPersistence()
1018                                       .findByC_C_C_First(companyId, classNameId, classPK,
1019                            orderByComparator);
1020            }
1021    
1022            /**
1023            * Returns the first website in the ordered set where companyId = &#63; and classNameId = &#63; and classPK = &#63;.
1024            *
1025            * @param companyId the company ID
1026            * @param classNameId the class name ID
1027            * @param classPK the class p k
1028            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1029            * @return the first matching website, or <code>null</code> if a matching website could not be found
1030            */
1031            public static Website fetchByC_C_C_First(long companyId, long classNameId,
1032                    long classPK, OrderByComparator<Website> orderByComparator) {
1033                    return getPersistence()
1034                                       .fetchByC_C_C_First(companyId, classNameId, classPK,
1035                            orderByComparator);
1036            }
1037    
1038            /**
1039            * Returns the last website in the ordered set where companyId = &#63; and classNameId = &#63; and classPK = &#63;.
1040            *
1041            * @param companyId the company ID
1042            * @param classNameId the class name ID
1043            * @param classPK the class p k
1044            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1045            * @return the last matching website
1046            * @throws NoSuchWebsiteException if a matching website could not be found
1047            */
1048            public static Website findByC_C_C_Last(long companyId, long classNameId,
1049                    long classPK, OrderByComparator<Website> orderByComparator)
1050                    throws com.liferay.portal.exception.NoSuchWebsiteException {
1051                    return getPersistence()
1052                                       .findByC_C_C_Last(companyId, classNameId, classPK,
1053                            orderByComparator);
1054            }
1055    
1056            /**
1057            * Returns the last website in the ordered set where companyId = &#63; and classNameId = &#63; and classPK = &#63;.
1058            *
1059            * @param companyId the company ID
1060            * @param classNameId the class name ID
1061            * @param classPK the class p k
1062            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1063            * @return the last matching website, or <code>null</code> if a matching website could not be found
1064            */
1065            public static Website fetchByC_C_C_Last(long companyId, long classNameId,
1066                    long classPK, OrderByComparator<Website> orderByComparator) {
1067                    return getPersistence()
1068                                       .fetchByC_C_C_Last(companyId, classNameId, classPK,
1069                            orderByComparator);
1070            }
1071    
1072            /**
1073            * Returns the websites before and after the current website in the ordered set where companyId = &#63; and classNameId = &#63; and classPK = &#63;.
1074            *
1075            * @param websiteId the primary key of the current website
1076            * @param companyId the company ID
1077            * @param classNameId the class name ID
1078            * @param classPK the class p k
1079            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1080            * @return the previous, current, and next website
1081            * @throws NoSuchWebsiteException if a website with the primary key could not be found
1082            */
1083            public static Website[] findByC_C_C_PrevAndNext(long websiteId,
1084                    long companyId, long classNameId, long classPK,
1085                    OrderByComparator<Website> orderByComparator)
1086                    throws com.liferay.portal.exception.NoSuchWebsiteException {
1087                    return getPersistence()
1088                                       .findByC_C_C_PrevAndNext(websiteId, companyId, classNameId,
1089                            classPK, orderByComparator);
1090            }
1091    
1092            /**
1093            * Removes all the websites where companyId = &#63; and classNameId = &#63; and classPK = &#63; from the database.
1094            *
1095            * @param companyId the company ID
1096            * @param classNameId the class name ID
1097            * @param classPK the class p k
1098            */
1099            public static void removeByC_C_C(long companyId, long classNameId,
1100                    long classPK) {
1101                    getPersistence().removeByC_C_C(companyId, classNameId, classPK);
1102            }
1103    
1104            /**
1105            * Returns the number of websites where companyId = &#63; and classNameId = &#63; and classPK = &#63;.
1106            *
1107            * @param companyId the company ID
1108            * @param classNameId the class name ID
1109            * @param classPK the class p k
1110            * @return the number of matching websites
1111            */
1112            public static int countByC_C_C(long companyId, long classNameId,
1113                    long classPK) {
1114                    return getPersistence().countByC_C_C(companyId, classNameId, classPK);
1115            }
1116    
1117            /**
1118            * Returns all the websites where companyId = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
1119            *
1120            * @param companyId the company ID
1121            * @param classNameId the class name ID
1122            * @param classPK the class p k
1123            * @param primary the primary
1124            * @return the matching websites
1125            */
1126            public static List<Website> findByC_C_C_P(long companyId, long classNameId,
1127                    long classPK, boolean primary) {
1128                    return getPersistence()
1129                                       .findByC_C_C_P(companyId, classNameId, classPK, primary);
1130            }
1131    
1132            /**
1133            * Returns a range of all the websites where companyId = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
1134            *
1135            * <p>
1136            * 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 WebsiteModelImpl}. 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.
1137            * </p>
1138            *
1139            * @param companyId the company ID
1140            * @param classNameId the class name ID
1141            * @param classPK the class p k
1142            * @param primary the primary
1143            * @param start the lower bound of the range of websites
1144            * @param end the upper bound of the range of websites (not inclusive)
1145            * @return the range of matching websites
1146            */
1147            public static List<Website> findByC_C_C_P(long companyId, long classNameId,
1148                    long classPK, boolean primary, int start, int end) {
1149                    return getPersistence()
1150                                       .findByC_C_C_P(companyId, classNameId, classPK, primary,
1151                            start, end);
1152            }
1153    
1154            /**
1155            * Returns an ordered range of all the websites where companyId = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
1156            *
1157            * <p>
1158            * 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 WebsiteModelImpl}. 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.
1159            * </p>
1160            *
1161            * @param companyId the company ID
1162            * @param classNameId the class name ID
1163            * @param classPK the class p k
1164            * @param primary the primary
1165            * @param start the lower bound of the range of websites
1166            * @param end the upper bound of the range of websites (not inclusive)
1167            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1168            * @return the ordered range of matching websites
1169            */
1170            public static List<Website> findByC_C_C_P(long companyId, long classNameId,
1171                    long classPK, boolean primary, int start, int end,
1172                    OrderByComparator<Website> orderByComparator) {
1173                    return getPersistence()
1174                                       .findByC_C_C_P(companyId, classNameId, classPK, primary,
1175                            start, end, orderByComparator);
1176            }
1177    
1178            /**
1179            * Returns an ordered range of all the websites where companyId = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
1180            *
1181            * <p>
1182            * 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 WebsiteModelImpl}. 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.
1183            * </p>
1184            *
1185            * @param companyId the company ID
1186            * @param classNameId the class name ID
1187            * @param classPK the class p k
1188            * @param primary the primary
1189            * @param start the lower bound of the range of websites
1190            * @param end the upper bound of the range of websites (not inclusive)
1191            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1192            * @param retrieveFromCache whether to retrieve from the finder cache
1193            * @return the ordered range of matching websites
1194            */
1195            public static List<Website> findByC_C_C_P(long companyId, long classNameId,
1196                    long classPK, boolean primary, int start, int end,
1197                    OrderByComparator<Website> orderByComparator, boolean retrieveFromCache) {
1198                    return getPersistence()
1199                                       .findByC_C_C_P(companyId, classNameId, classPK, primary,
1200                            start, end, orderByComparator, retrieveFromCache);
1201            }
1202    
1203            /**
1204            * Returns the first website in the ordered set where companyId = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
1205            *
1206            * @param companyId the company ID
1207            * @param classNameId the class name ID
1208            * @param classPK the class p k
1209            * @param primary the primary
1210            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1211            * @return the first matching website
1212            * @throws NoSuchWebsiteException if a matching website could not be found
1213            */
1214            public static Website findByC_C_C_P_First(long companyId, long classNameId,
1215                    long classPK, boolean primary,
1216                    OrderByComparator<Website> orderByComparator)
1217                    throws com.liferay.portal.exception.NoSuchWebsiteException {
1218                    return getPersistence()
1219                                       .findByC_C_C_P_First(companyId, classNameId, classPK,
1220                            primary, orderByComparator);
1221            }
1222    
1223            /**
1224            * Returns the first website in the ordered set where companyId = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
1225            *
1226            * @param companyId the company ID
1227            * @param classNameId the class name ID
1228            * @param classPK the class p k
1229            * @param primary the primary
1230            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1231            * @return the first matching website, or <code>null</code> if a matching website could not be found
1232            */
1233            public static Website fetchByC_C_C_P_First(long companyId,
1234                    long classNameId, long classPK, boolean primary,
1235                    OrderByComparator<Website> orderByComparator) {
1236                    return getPersistence()
1237                                       .fetchByC_C_C_P_First(companyId, classNameId, classPK,
1238                            primary, orderByComparator);
1239            }
1240    
1241            /**
1242            * Returns the last website in the ordered set where companyId = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
1243            *
1244            * @param companyId the company ID
1245            * @param classNameId the class name ID
1246            * @param classPK the class p k
1247            * @param primary the primary
1248            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1249            * @return the last matching website
1250            * @throws NoSuchWebsiteException if a matching website could not be found
1251            */
1252            public static Website findByC_C_C_P_Last(long companyId, long classNameId,
1253                    long classPK, boolean primary,
1254                    OrderByComparator<Website> orderByComparator)
1255                    throws com.liferay.portal.exception.NoSuchWebsiteException {
1256                    return getPersistence()
1257                                       .findByC_C_C_P_Last(companyId, classNameId, classPK,
1258                            primary, orderByComparator);
1259            }
1260    
1261            /**
1262            * Returns the last website in the ordered set where companyId = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
1263            *
1264            * @param companyId the company ID
1265            * @param classNameId the class name ID
1266            * @param classPK the class p k
1267            * @param primary the primary
1268            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1269            * @return the last matching website, or <code>null</code> if a matching website could not be found
1270            */
1271            public static Website fetchByC_C_C_P_Last(long companyId, long classNameId,
1272                    long classPK, boolean primary,
1273                    OrderByComparator<Website> orderByComparator) {
1274                    return getPersistence()
1275                                       .fetchByC_C_C_P_Last(companyId, classNameId, classPK,
1276                            primary, orderByComparator);
1277            }
1278    
1279            /**
1280            * Returns the websites before and after the current website in the ordered set where companyId = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
1281            *
1282            * @param websiteId the primary key of the current website
1283            * @param companyId the company ID
1284            * @param classNameId the class name ID
1285            * @param classPK the class p k
1286            * @param primary the primary
1287            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1288            * @return the previous, current, and next website
1289            * @throws NoSuchWebsiteException if a website with the primary key could not be found
1290            */
1291            public static Website[] findByC_C_C_P_PrevAndNext(long websiteId,
1292                    long companyId, long classNameId, long classPK, boolean primary,
1293                    OrderByComparator<Website> orderByComparator)
1294                    throws com.liferay.portal.exception.NoSuchWebsiteException {
1295                    return getPersistence()
1296                                       .findByC_C_C_P_PrevAndNext(websiteId, companyId,
1297                            classNameId, classPK, primary, orderByComparator);
1298            }
1299    
1300            /**
1301            * Removes all the websites where companyId = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63; from the database.
1302            *
1303            * @param companyId the company ID
1304            * @param classNameId the class name ID
1305            * @param classPK the class p k
1306            * @param primary the primary
1307            */
1308            public static void removeByC_C_C_P(long companyId, long classNameId,
1309                    long classPK, boolean primary) {
1310                    getPersistence()
1311                            .removeByC_C_C_P(companyId, classNameId, classPK, primary);
1312            }
1313    
1314            /**
1315            * Returns the number of websites where companyId = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
1316            *
1317            * @param companyId the company ID
1318            * @param classNameId the class name ID
1319            * @param classPK the class p k
1320            * @param primary the primary
1321            * @return the number of matching websites
1322            */
1323            public static int countByC_C_C_P(long companyId, long classNameId,
1324                    long classPK, boolean primary) {
1325                    return getPersistence()
1326                                       .countByC_C_C_P(companyId, classNameId, classPK, primary);
1327            }
1328    
1329            /**
1330            * Caches the website in the entity cache if it is enabled.
1331            *
1332            * @param website the website
1333            */
1334            public static void cacheResult(Website website) {
1335                    getPersistence().cacheResult(website);
1336            }
1337    
1338            /**
1339            * Caches the websites in the entity cache if it is enabled.
1340            *
1341            * @param websites the websites
1342            */
1343            public static void cacheResult(List<Website> websites) {
1344                    getPersistence().cacheResult(websites);
1345            }
1346    
1347            /**
1348            * Creates a new website with the primary key. Does not add the website to the database.
1349            *
1350            * @param websiteId the primary key for the new website
1351            * @return the new website
1352            */
1353            public static Website create(long websiteId) {
1354                    return getPersistence().create(websiteId);
1355            }
1356    
1357            /**
1358            * Removes the website with the primary key from the database. Also notifies the appropriate model listeners.
1359            *
1360            * @param websiteId the primary key of the website
1361            * @return the website that was removed
1362            * @throws NoSuchWebsiteException if a website with the primary key could not be found
1363            */
1364            public static Website remove(long websiteId)
1365                    throws com.liferay.portal.exception.NoSuchWebsiteException {
1366                    return getPersistence().remove(websiteId);
1367            }
1368    
1369            public static Website updateImpl(Website website) {
1370                    return getPersistence().updateImpl(website);
1371            }
1372    
1373            /**
1374            * Returns the website with the primary key or throws a {@link NoSuchWebsiteException} if it could not be found.
1375            *
1376            * @param websiteId the primary key of the website
1377            * @return the website
1378            * @throws NoSuchWebsiteException if a website with the primary key could not be found
1379            */
1380            public static Website findByPrimaryKey(long websiteId)
1381                    throws com.liferay.portal.exception.NoSuchWebsiteException {
1382                    return getPersistence().findByPrimaryKey(websiteId);
1383            }
1384    
1385            /**
1386            * Returns the website with the primary key or returns <code>null</code> if it could not be found.
1387            *
1388            * @param websiteId the primary key of the website
1389            * @return the website, or <code>null</code> if a website with the primary key could not be found
1390            */
1391            public static Website fetchByPrimaryKey(long websiteId) {
1392                    return getPersistence().fetchByPrimaryKey(websiteId);
1393            }
1394    
1395            public static java.util.Map<java.io.Serializable, Website> fetchByPrimaryKeys(
1396                    java.util.Set<java.io.Serializable> primaryKeys) {
1397                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
1398            }
1399    
1400            /**
1401            * Returns all the websites.
1402            *
1403            * @return the websites
1404            */
1405            public static List<Website> findAll() {
1406                    return getPersistence().findAll();
1407            }
1408    
1409            /**
1410            * Returns a range of all the websites.
1411            *
1412            * <p>
1413            * 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 WebsiteModelImpl}. 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.
1414            * </p>
1415            *
1416            * @param start the lower bound of the range of websites
1417            * @param end the upper bound of the range of websites (not inclusive)
1418            * @return the range of websites
1419            */
1420            public static List<Website> findAll(int start, int end) {
1421                    return getPersistence().findAll(start, end);
1422            }
1423    
1424            /**
1425            * Returns an ordered range of all the websites.
1426            *
1427            * <p>
1428            * 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 WebsiteModelImpl}. 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.
1429            * </p>
1430            *
1431            * @param start the lower bound of the range of websites
1432            * @param end the upper bound of the range of websites (not inclusive)
1433            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1434            * @return the ordered range of websites
1435            */
1436            public static List<Website> findAll(int start, int end,
1437                    OrderByComparator<Website> orderByComparator) {
1438                    return getPersistence().findAll(start, end, orderByComparator);
1439            }
1440    
1441            /**
1442            * Returns an ordered range of all the websites.
1443            *
1444            * <p>
1445            * 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 WebsiteModelImpl}. 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.
1446            * </p>
1447            *
1448            * @param start the lower bound of the range of websites
1449            * @param end the upper bound of the range of websites (not inclusive)
1450            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1451            * @param retrieveFromCache whether to retrieve from the finder cache
1452            * @return the ordered range of websites
1453            */
1454            public static List<Website> findAll(int start, int end,
1455                    OrderByComparator<Website> orderByComparator, boolean retrieveFromCache) {
1456                    return getPersistence()
1457                                       .findAll(start, end, orderByComparator, retrieveFromCache);
1458            }
1459    
1460            /**
1461            * Removes all the websites from the database.
1462            */
1463            public static void removeAll() {
1464                    getPersistence().removeAll();
1465            }
1466    
1467            /**
1468            * Returns the number of websites.
1469            *
1470            * @return the number of websites
1471            */
1472            public static int countAll() {
1473                    return getPersistence().countAll();
1474            }
1475    
1476            public static java.util.Set<java.lang.String> getBadColumnNames() {
1477                    return getPersistence().getBadColumnNames();
1478            }
1479    
1480            public static WebsitePersistence getPersistence() {
1481                    if (_persistence == null) {
1482                            _persistence = (WebsitePersistence)PortalBeanLocatorUtil.locate(WebsitePersistence.class.getName());
1483    
1484                            ReferenceRegistry.registerReference(WebsiteUtil.class,
1485                                    "_persistence");
1486                    }
1487    
1488                    return _persistence;
1489            }
1490    
1491            private static WebsitePersistence _persistence;
1492    }