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.model.Phone;
020    
021    /**
022     * The persistence interface for the phone service.
023     *
024     * <p>
025     * Caching information and settings can be found in <code>portal.properties</code>
026     * </p>
027     *
028     * @author Brian Wing Shun Chan
029     * @see com.liferay.portal.service.persistence.impl.PhonePersistenceImpl
030     * @see PhoneUtil
031     * @generated
032     */
033    @ProviderType
034    public interface PhonePersistence extends BasePersistence<Phone> {
035            /*
036             * NOTE FOR DEVELOPERS:
037             *
038             * Never modify or reference this interface directly. Always use {@link PhoneUtil} to access the phone persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface.
039             */
040    
041            /**
042            * Returns all the phones where uuid = &#63;.
043            *
044            * @param uuid the uuid
045            * @return the matching phones
046            */
047            public java.util.List<Phone> findByUuid(java.lang.String uuid);
048    
049            /**
050            * Returns a range of all the phones where uuid = &#63;.
051            *
052            * <p>
053            * 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 PhoneModelImpl}. 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.
054            * </p>
055            *
056            * @param uuid the uuid
057            * @param start the lower bound of the range of phones
058            * @param end the upper bound of the range of phones (not inclusive)
059            * @return the range of matching phones
060            */
061            public java.util.List<Phone> findByUuid(java.lang.String uuid, int start,
062                    int end);
063    
064            /**
065            * Returns an ordered range of all the phones where uuid = &#63;.
066            *
067            * <p>
068            * 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 PhoneModelImpl}. 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.
069            * </p>
070            *
071            * @param uuid the uuid
072            * @param start the lower bound of the range of phones
073            * @param end the upper bound of the range of phones (not inclusive)
074            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
075            * @return the ordered range of matching phones
076            */
077            public java.util.List<Phone> findByUuid(java.lang.String uuid, int start,
078                    int end,
079                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator);
080    
081            /**
082            * Returns an ordered range of all the phones where uuid = &#63;.
083            *
084            * <p>
085            * 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 PhoneModelImpl}. 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.
086            * </p>
087            *
088            * @param uuid the uuid
089            * @param start the lower bound of the range of phones
090            * @param end the upper bound of the range of phones (not inclusive)
091            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
092            * @param retrieveFromCache whether to retrieve from the finder cache
093            * @return the ordered range of matching phones
094            */
095            public java.util.List<Phone> findByUuid(java.lang.String uuid, int start,
096                    int end,
097                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator,
098                    boolean retrieveFromCache);
099    
100            /**
101            * Returns the first phone in the ordered set where uuid = &#63;.
102            *
103            * @param uuid the uuid
104            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
105            * @return the first matching phone
106            * @throws NoSuchPhoneException if a matching phone could not be found
107            */
108            public Phone findByUuid_First(java.lang.String uuid,
109                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator)
110                    throws com.liferay.portal.exception.NoSuchPhoneException;
111    
112            /**
113            * Returns the first phone in the ordered set where uuid = &#63;.
114            *
115            * @param uuid the uuid
116            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
117            * @return the first matching phone, or <code>null</code> if a matching phone could not be found
118            */
119            public Phone fetchByUuid_First(java.lang.String uuid,
120                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator);
121    
122            /**
123            * Returns the last phone in the ordered set where uuid = &#63;.
124            *
125            * @param uuid the uuid
126            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
127            * @return the last matching phone
128            * @throws NoSuchPhoneException if a matching phone could not be found
129            */
130            public Phone findByUuid_Last(java.lang.String uuid,
131                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator)
132                    throws com.liferay.portal.exception.NoSuchPhoneException;
133    
134            /**
135            * Returns the last phone in the ordered set where uuid = &#63;.
136            *
137            * @param uuid the uuid
138            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
139            * @return the last matching phone, or <code>null</code> if a matching phone could not be found
140            */
141            public Phone fetchByUuid_Last(java.lang.String uuid,
142                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator);
143    
144            /**
145            * Returns the phones before and after the current phone in the ordered set where uuid = &#63;.
146            *
147            * @param phoneId the primary key of the current phone
148            * @param uuid the uuid
149            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
150            * @return the previous, current, and next phone
151            * @throws NoSuchPhoneException if a phone with the primary key could not be found
152            */
153            public Phone[] findByUuid_PrevAndNext(long phoneId, java.lang.String uuid,
154                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator)
155                    throws com.liferay.portal.exception.NoSuchPhoneException;
156    
157            /**
158            * Removes all the phones where uuid = &#63; from the database.
159            *
160            * @param uuid the uuid
161            */
162            public void removeByUuid(java.lang.String uuid);
163    
164            /**
165            * Returns the number of phones where uuid = &#63;.
166            *
167            * @param uuid the uuid
168            * @return the number of matching phones
169            */
170            public int countByUuid(java.lang.String uuid);
171    
172            /**
173            * Returns all the phones where uuid = &#63; and companyId = &#63;.
174            *
175            * @param uuid the uuid
176            * @param companyId the company ID
177            * @return the matching phones
178            */
179            public java.util.List<Phone> findByUuid_C(java.lang.String uuid,
180                    long companyId);
181    
182            /**
183            * Returns a range of all the phones where uuid = &#63; and companyId = &#63;.
184            *
185            * <p>
186            * 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 PhoneModelImpl}. 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.
187            * </p>
188            *
189            * @param uuid the uuid
190            * @param companyId the company ID
191            * @param start the lower bound of the range of phones
192            * @param end the upper bound of the range of phones (not inclusive)
193            * @return the range of matching phones
194            */
195            public java.util.List<Phone> findByUuid_C(java.lang.String uuid,
196                    long companyId, int start, int end);
197    
198            /**
199            * Returns an ordered range of all the phones where uuid = &#63; and companyId = &#63;.
200            *
201            * <p>
202            * 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 PhoneModelImpl}. 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.
203            * </p>
204            *
205            * @param uuid the uuid
206            * @param companyId the company ID
207            * @param start the lower bound of the range of phones
208            * @param end the upper bound of the range of phones (not inclusive)
209            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
210            * @return the ordered range of matching phones
211            */
212            public java.util.List<Phone> findByUuid_C(java.lang.String uuid,
213                    long companyId, int start, int end,
214                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator);
215    
216            /**
217            * Returns an ordered range of all the phones where uuid = &#63; and companyId = &#63;.
218            *
219            * <p>
220            * 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 PhoneModelImpl}. 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.
221            * </p>
222            *
223            * @param uuid the uuid
224            * @param companyId the company ID
225            * @param start the lower bound of the range of phones
226            * @param end the upper bound of the range of phones (not inclusive)
227            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
228            * @param retrieveFromCache whether to retrieve from the finder cache
229            * @return the ordered range of matching phones
230            */
231            public java.util.List<Phone> findByUuid_C(java.lang.String uuid,
232                    long companyId, int start, int end,
233                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator,
234                    boolean retrieveFromCache);
235    
236            /**
237            * Returns the first phone in the ordered set where uuid = &#63; and companyId = &#63;.
238            *
239            * @param uuid the uuid
240            * @param companyId the company ID
241            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
242            * @return the first matching phone
243            * @throws NoSuchPhoneException if a matching phone could not be found
244            */
245            public Phone findByUuid_C_First(java.lang.String uuid, long companyId,
246                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator)
247                    throws com.liferay.portal.exception.NoSuchPhoneException;
248    
249            /**
250            * Returns the first phone in the ordered set where uuid = &#63; and companyId = &#63;.
251            *
252            * @param uuid the uuid
253            * @param companyId the company ID
254            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
255            * @return the first matching phone, or <code>null</code> if a matching phone could not be found
256            */
257            public Phone fetchByUuid_C_First(java.lang.String uuid, long companyId,
258                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator);
259    
260            /**
261            * Returns the last phone in the ordered set where uuid = &#63; and companyId = &#63;.
262            *
263            * @param uuid the uuid
264            * @param companyId the company ID
265            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
266            * @return the last matching phone
267            * @throws NoSuchPhoneException if a matching phone could not be found
268            */
269            public Phone findByUuid_C_Last(java.lang.String uuid, long companyId,
270                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator)
271                    throws com.liferay.portal.exception.NoSuchPhoneException;
272    
273            /**
274            * Returns the last phone in the ordered set where uuid = &#63; and companyId = &#63;.
275            *
276            * @param uuid the uuid
277            * @param companyId the company ID
278            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
279            * @return the last matching phone, or <code>null</code> if a matching phone could not be found
280            */
281            public Phone fetchByUuid_C_Last(java.lang.String uuid, long companyId,
282                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator);
283    
284            /**
285            * Returns the phones before and after the current phone in the ordered set where uuid = &#63; and companyId = &#63;.
286            *
287            * @param phoneId the primary key of the current phone
288            * @param uuid the uuid
289            * @param companyId the company ID
290            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
291            * @return the previous, current, and next phone
292            * @throws NoSuchPhoneException if a phone with the primary key could not be found
293            */
294            public Phone[] findByUuid_C_PrevAndNext(long phoneId,
295                    java.lang.String uuid, long companyId,
296                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator)
297                    throws com.liferay.portal.exception.NoSuchPhoneException;
298    
299            /**
300            * Removes all the phones where uuid = &#63; and companyId = &#63; from the database.
301            *
302            * @param uuid the uuid
303            * @param companyId the company ID
304            */
305            public void removeByUuid_C(java.lang.String uuid, long companyId);
306    
307            /**
308            * Returns the number of phones where uuid = &#63; and companyId = &#63;.
309            *
310            * @param uuid the uuid
311            * @param companyId the company ID
312            * @return the number of matching phones
313            */
314            public int countByUuid_C(java.lang.String uuid, long companyId);
315    
316            /**
317            * Returns all the phones where companyId = &#63;.
318            *
319            * @param companyId the company ID
320            * @return the matching phones
321            */
322            public java.util.List<Phone> findByCompanyId(long companyId);
323    
324            /**
325            * Returns a range of all the phones where companyId = &#63;.
326            *
327            * <p>
328            * 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 PhoneModelImpl}. 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.
329            * </p>
330            *
331            * @param companyId the company ID
332            * @param start the lower bound of the range of phones
333            * @param end the upper bound of the range of phones (not inclusive)
334            * @return the range of matching phones
335            */
336            public java.util.List<Phone> findByCompanyId(long companyId, int start,
337                    int end);
338    
339            /**
340            * Returns an ordered range of all the phones where companyId = &#63;.
341            *
342            * <p>
343            * 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 PhoneModelImpl}. 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.
344            * </p>
345            *
346            * @param companyId the company ID
347            * @param start the lower bound of the range of phones
348            * @param end the upper bound of the range of phones (not inclusive)
349            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
350            * @return the ordered range of matching phones
351            */
352            public java.util.List<Phone> findByCompanyId(long companyId, int start,
353                    int end,
354                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator);
355    
356            /**
357            * Returns an ordered range of all the phones where companyId = &#63;.
358            *
359            * <p>
360            * 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 PhoneModelImpl}. 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.
361            * </p>
362            *
363            * @param companyId the company ID
364            * @param start the lower bound of the range of phones
365            * @param end the upper bound of the range of phones (not inclusive)
366            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
367            * @param retrieveFromCache whether to retrieve from the finder cache
368            * @return the ordered range of matching phones
369            */
370            public java.util.List<Phone> findByCompanyId(long companyId, int start,
371                    int end,
372                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator,
373                    boolean retrieveFromCache);
374    
375            /**
376            * Returns the first phone in the ordered set where companyId = &#63;.
377            *
378            * @param companyId the company ID
379            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
380            * @return the first matching phone
381            * @throws NoSuchPhoneException if a matching phone could not be found
382            */
383            public Phone findByCompanyId_First(long companyId,
384                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator)
385                    throws com.liferay.portal.exception.NoSuchPhoneException;
386    
387            /**
388            * Returns the first phone in the ordered set where companyId = &#63;.
389            *
390            * @param companyId the company ID
391            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
392            * @return the first matching phone, or <code>null</code> if a matching phone could not be found
393            */
394            public Phone fetchByCompanyId_First(long companyId,
395                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator);
396    
397            /**
398            * Returns the last phone in the ordered set where companyId = &#63;.
399            *
400            * @param companyId the company ID
401            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
402            * @return the last matching phone
403            * @throws NoSuchPhoneException if a matching phone could not be found
404            */
405            public Phone findByCompanyId_Last(long companyId,
406                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator)
407                    throws com.liferay.portal.exception.NoSuchPhoneException;
408    
409            /**
410            * Returns the last phone in the ordered set where companyId = &#63;.
411            *
412            * @param companyId the company ID
413            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
414            * @return the last matching phone, or <code>null</code> if a matching phone could not be found
415            */
416            public Phone fetchByCompanyId_Last(long companyId,
417                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator);
418    
419            /**
420            * Returns the phones before and after the current phone in the ordered set where companyId = &#63;.
421            *
422            * @param phoneId the primary key of the current phone
423            * @param companyId the company ID
424            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
425            * @return the previous, current, and next phone
426            * @throws NoSuchPhoneException if a phone with the primary key could not be found
427            */
428            public Phone[] findByCompanyId_PrevAndNext(long phoneId, long companyId,
429                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator)
430                    throws com.liferay.portal.exception.NoSuchPhoneException;
431    
432            /**
433            * Removes all the phones where companyId = &#63; from the database.
434            *
435            * @param companyId the company ID
436            */
437            public void removeByCompanyId(long companyId);
438    
439            /**
440            * Returns the number of phones where companyId = &#63;.
441            *
442            * @param companyId the company ID
443            * @return the number of matching phones
444            */
445            public int countByCompanyId(long companyId);
446    
447            /**
448            * Returns all the phones where userId = &#63;.
449            *
450            * @param userId the user ID
451            * @return the matching phones
452            */
453            public java.util.List<Phone> findByUserId(long userId);
454    
455            /**
456            * Returns a range of all the phones where userId = &#63;.
457            *
458            * <p>
459            * 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 PhoneModelImpl}. 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.
460            * </p>
461            *
462            * @param userId the user ID
463            * @param start the lower bound of the range of phones
464            * @param end the upper bound of the range of phones (not inclusive)
465            * @return the range of matching phones
466            */
467            public java.util.List<Phone> findByUserId(long userId, int start, int end);
468    
469            /**
470            * Returns an ordered range of all the phones where userId = &#63;.
471            *
472            * <p>
473            * 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 PhoneModelImpl}. 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.
474            * </p>
475            *
476            * @param userId the user ID
477            * @param start the lower bound of the range of phones
478            * @param end the upper bound of the range of phones (not inclusive)
479            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
480            * @return the ordered range of matching phones
481            */
482            public java.util.List<Phone> findByUserId(long userId, int start, int end,
483                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator);
484    
485            /**
486            * Returns an ordered range of all the phones where userId = &#63;.
487            *
488            * <p>
489            * 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 PhoneModelImpl}. 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.
490            * </p>
491            *
492            * @param userId the user ID
493            * @param start the lower bound of the range of phones
494            * @param end the upper bound of the range of phones (not inclusive)
495            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
496            * @param retrieveFromCache whether to retrieve from the finder cache
497            * @return the ordered range of matching phones
498            */
499            public java.util.List<Phone> findByUserId(long userId, int start, int end,
500                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator,
501                    boolean retrieveFromCache);
502    
503            /**
504            * Returns the first phone in the ordered set where userId = &#63;.
505            *
506            * @param userId the user ID
507            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
508            * @return the first matching phone
509            * @throws NoSuchPhoneException if a matching phone could not be found
510            */
511            public Phone findByUserId_First(long userId,
512                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator)
513                    throws com.liferay.portal.exception.NoSuchPhoneException;
514    
515            /**
516            * Returns the first phone in the ordered set where userId = &#63;.
517            *
518            * @param userId the user ID
519            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
520            * @return the first matching phone, or <code>null</code> if a matching phone could not be found
521            */
522            public Phone fetchByUserId_First(long userId,
523                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator);
524    
525            /**
526            * Returns the last phone in the ordered set where userId = &#63;.
527            *
528            * @param userId the user ID
529            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
530            * @return the last matching phone
531            * @throws NoSuchPhoneException if a matching phone could not be found
532            */
533            public Phone findByUserId_Last(long userId,
534                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator)
535                    throws com.liferay.portal.exception.NoSuchPhoneException;
536    
537            /**
538            * Returns the last phone in the ordered set where userId = &#63;.
539            *
540            * @param userId the user ID
541            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
542            * @return the last matching phone, or <code>null</code> if a matching phone could not be found
543            */
544            public Phone fetchByUserId_Last(long userId,
545                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator);
546    
547            /**
548            * Returns the phones before and after the current phone in the ordered set where userId = &#63;.
549            *
550            * @param phoneId the primary key of the current phone
551            * @param userId the user ID
552            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
553            * @return the previous, current, and next phone
554            * @throws NoSuchPhoneException if a phone with the primary key could not be found
555            */
556            public Phone[] findByUserId_PrevAndNext(long phoneId, long userId,
557                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator)
558                    throws com.liferay.portal.exception.NoSuchPhoneException;
559    
560            /**
561            * Removes all the phones where userId = &#63; from the database.
562            *
563            * @param userId the user ID
564            */
565            public void removeByUserId(long userId);
566    
567            /**
568            * Returns the number of phones where userId = &#63;.
569            *
570            * @param userId the user ID
571            * @return the number of matching phones
572            */
573            public int countByUserId(long userId);
574    
575            /**
576            * Returns all the phones where companyId = &#63; and classNameId = &#63;.
577            *
578            * @param companyId the company ID
579            * @param classNameId the class name ID
580            * @return the matching phones
581            */
582            public java.util.List<Phone> findByC_C(long companyId, long classNameId);
583    
584            /**
585            * Returns a range of all the phones where companyId = &#63; and classNameId = &#63;.
586            *
587            * <p>
588            * 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 PhoneModelImpl}. 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.
589            * </p>
590            *
591            * @param companyId the company ID
592            * @param classNameId the class name ID
593            * @param start the lower bound of the range of phones
594            * @param end the upper bound of the range of phones (not inclusive)
595            * @return the range of matching phones
596            */
597            public java.util.List<Phone> findByC_C(long companyId, long classNameId,
598                    int start, int end);
599    
600            /**
601            * Returns an ordered range of all the phones where companyId = &#63; and classNameId = &#63;.
602            *
603            * <p>
604            * 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 PhoneModelImpl}. 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.
605            * </p>
606            *
607            * @param companyId the company ID
608            * @param classNameId the class name ID
609            * @param start the lower bound of the range of phones
610            * @param end the upper bound of the range of phones (not inclusive)
611            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
612            * @return the ordered range of matching phones
613            */
614            public java.util.List<Phone> findByC_C(long companyId, long classNameId,
615                    int start, int end,
616                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator);
617    
618            /**
619            * Returns an ordered range of all the phones where companyId = &#63; and classNameId = &#63;.
620            *
621            * <p>
622            * 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 PhoneModelImpl}. 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.
623            * </p>
624            *
625            * @param companyId the company ID
626            * @param classNameId the class name ID
627            * @param start the lower bound of the range of phones
628            * @param end the upper bound of the range of phones (not inclusive)
629            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
630            * @param retrieveFromCache whether to retrieve from the finder cache
631            * @return the ordered range of matching phones
632            */
633            public java.util.List<Phone> findByC_C(long companyId, long classNameId,
634                    int start, int end,
635                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator,
636                    boolean retrieveFromCache);
637    
638            /**
639            * Returns the first phone in the ordered set where companyId = &#63; and classNameId = &#63;.
640            *
641            * @param companyId the company ID
642            * @param classNameId the class name ID
643            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
644            * @return the first matching phone
645            * @throws NoSuchPhoneException if a matching phone could not be found
646            */
647            public Phone findByC_C_First(long companyId, long classNameId,
648                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator)
649                    throws com.liferay.portal.exception.NoSuchPhoneException;
650    
651            /**
652            * Returns the first phone in the ordered set where companyId = &#63; and classNameId = &#63;.
653            *
654            * @param companyId the company ID
655            * @param classNameId the class name ID
656            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
657            * @return the first matching phone, or <code>null</code> if a matching phone could not be found
658            */
659            public Phone fetchByC_C_First(long companyId, long classNameId,
660                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator);
661    
662            /**
663            * Returns the last phone in the ordered set where companyId = &#63; and classNameId = &#63;.
664            *
665            * @param companyId the company ID
666            * @param classNameId the class name ID
667            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
668            * @return the last matching phone
669            * @throws NoSuchPhoneException if a matching phone could not be found
670            */
671            public Phone findByC_C_Last(long companyId, long classNameId,
672                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator)
673                    throws com.liferay.portal.exception.NoSuchPhoneException;
674    
675            /**
676            * Returns the last phone in the ordered set where companyId = &#63; and classNameId = &#63;.
677            *
678            * @param companyId the company ID
679            * @param classNameId the class name ID
680            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
681            * @return the last matching phone, or <code>null</code> if a matching phone could not be found
682            */
683            public Phone fetchByC_C_Last(long companyId, long classNameId,
684                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator);
685    
686            /**
687            * Returns the phones before and after the current phone in the ordered set where companyId = &#63; and classNameId = &#63;.
688            *
689            * @param phoneId the primary key of the current phone
690            * @param companyId the company ID
691            * @param classNameId the class name ID
692            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
693            * @return the previous, current, and next phone
694            * @throws NoSuchPhoneException if a phone with the primary key could not be found
695            */
696            public Phone[] findByC_C_PrevAndNext(long phoneId, long companyId,
697                    long classNameId,
698                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator)
699                    throws com.liferay.portal.exception.NoSuchPhoneException;
700    
701            /**
702            * Removes all the phones where companyId = &#63; and classNameId = &#63; from the database.
703            *
704            * @param companyId the company ID
705            * @param classNameId the class name ID
706            */
707            public void removeByC_C(long companyId, long classNameId);
708    
709            /**
710            * Returns the number of phones where companyId = &#63; and classNameId = &#63;.
711            *
712            * @param companyId the company ID
713            * @param classNameId the class name ID
714            * @return the number of matching phones
715            */
716            public int countByC_C(long companyId, long classNameId);
717    
718            /**
719            * Returns all the phones where companyId = &#63; and classNameId = &#63; and classPK = &#63;.
720            *
721            * @param companyId the company ID
722            * @param classNameId the class name ID
723            * @param classPK the class p k
724            * @return the matching phones
725            */
726            public java.util.List<Phone> findByC_C_C(long companyId, long classNameId,
727                    long classPK);
728    
729            /**
730            * Returns a range of all the phones where companyId = &#63; and classNameId = &#63; and classPK = &#63;.
731            *
732            * <p>
733            * 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 PhoneModelImpl}. 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.
734            * </p>
735            *
736            * @param companyId the company ID
737            * @param classNameId the class name ID
738            * @param classPK the class p k
739            * @param start the lower bound of the range of phones
740            * @param end the upper bound of the range of phones (not inclusive)
741            * @return the range of matching phones
742            */
743            public java.util.List<Phone> findByC_C_C(long companyId, long classNameId,
744                    long classPK, int start, int end);
745    
746            /**
747            * Returns an ordered range of all the phones where companyId = &#63; and classNameId = &#63; and classPK = &#63;.
748            *
749            * <p>
750            * 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 PhoneModelImpl}. 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.
751            * </p>
752            *
753            * @param companyId the company ID
754            * @param classNameId the class name ID
755            * @param classPK the class p k
756            * @param start the lower bound of the range of phones
757            * @param end the upper bound of the range of phones (not inclusive)
758            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
759            * @return the ordered range of matching phones
760            */
761            public java.util.List<Phone> findByC_C_C(long companyId, long classNameId,
762                    long classPK, int start, int end,
763                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator);
764    
765            /**
766            * Returns an ordered range of all the phones where companyId = &#63; and classNameId = &#63; and classPK = &#63;.
767            *
768            * <p>
769            * 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 PhoneModelImpl}. 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.
770            * </p>
771            *
772            * @param companyId the company ID
773            * @param classNameId the class name ID
774            * @param classPK the class p k
775            * @param start the lower bound of the range of phones
776            * @param end the upper bound of the range of phones (not inclusive)
777            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
778            * @param retrieveFromCache whether to retrieve from the finder cache
779            * @return the ordered range of matching phones
780            */
781            public java.util.List<Phone> findByC_C_C(long companyId, long classNameId,
782                    long classPK, int start, int end,
783                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator,
784                    boolean retrieveFromCache);
785    
786            /**
787            * Returns the first phone in the ordered set where companyId = &#63; and classNameId = &#63; and classPK = &#63;.
788            *
789            * @param companyId the company ID
790            * @param classNameId the class name ID
791            * @param classPK the class p k
792            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
793            * @return the first matching phone
794            * @throws NoSuchPhoneException if a matching phone could not be found
795            */
796            public Phone findByC_C_C_First(long companyId, long classNameId,
797                    long classPK,
798                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator)
799                    throws com.liferay.portal.exception.NoSuchPhoneException;
800    
801            /**
802            * Returns the first phone in the ordered set where companyId = &#63; and classNameId = &#63; and classPK = &#63;.
803            *
804            * @param companyId the company ID
805            * @param classNameId the class name ID
806            * @param classPK the class p k
807            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
808            * @return the first matching phone, or <code>null</code> if a matching phone could not be found
809            */
810            public Phone fetchByC_C_C_First(long companyId, long classNameId,
811                    long classPK,
812                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator);
813    
814            /**
815            * Returns the last phone in the ordered set where companyId = &#63; and classNameId = &#63; and classPK = &#63;.
816            *
817            * @param companyId the company ID
818            * @param classNameId the class name ID
819            * @param classPK the class p k
820            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
821            * @return the last matching phone
822            * @throws NoSuchPhoneException if a matching phone could not be found
823            */
824            public Phone findByC_C_C_Last(long companyId, long classNameId,
825                    long classPK,
826                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator)
827                    throws com.liferay.portal.exception.NoSuchPhoneException;
828    
829            /**
830            * Returns the last phone in the ordered set where companyId = &#63; and classNameId = &#63; and classPK = &#63;.
831            *
832            * @param companyId the company ID
833            * @param classNameId the class name ID
834            * @param classPK the class p k
835            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
836            * @return the last matching phone, or <code>null</code> if a matching phone could not be found
837            */
838            public Phone fetchByC_C_C_Last(long companyId, long classNameId,
839                    long classPK,
840                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator);
841    
842            /**
843            * Returns the phones before and after the current phone in the ordered set where companyId = &#63; and classNameId = &#63; and classPK = &#63;.
844            *
845            * @param phoneId the primary key of the current phone
846            * @param companyId the company ID
847            * @param classNameId the class name ID
848            * @param classPK the class p k
849            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
850            * @return the previous, current, and next phone
851            * @throws NoSuchPhoneException if a phone with the primary key could not be found
852            */
853            public Phone[] findByC_C_C_PrevAndNext(long phoneId, long companyId,
854                    long classNameId, long classPK,
855                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator)
856                    throws com.liferay.portal.exception.NoSuchPhoneException;
857    
858            /**
859            * Removes all the phones where companyId = &#63; and classNameId = &#63; and classPK = &#63; from the database.
860            *
861            * @param companyId the company ID
862            * @param classNameId the class name ID
863            * @param classPK the class p k
864            */
865            public void removeByC_C_C(long companyId, long classNameId, long classPK);
866    
867            /**
868            * Returns the number of phones where companyId = &#63; and classNameId = &#63; and classPK = &#63;.
869            *
870            * @param companyId the company ID
871            * @param classNameId the class name ID
872            * @param classPK the class p k
873            * @return the number of matching phones
874            */
875            public int countByC_C_C(long companyId, long classNameId, long classPK);
876    
877            /**
878            * Returns all the phones where companyId = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
879            *
880            * @param companyId the company ID
881            * @param classNameId the class name ID
882            * @param classPK the class p k
883            * @param primary the primary
884            * @return the matching phones
885            */
886            public java.util.List<Phone> findByC_C_C_P(long companyId,
887                    long classNameId, long classPK, boolean primary);
888    
889            /**
890            * Returns a range of all the phones where companyId = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
891            *
892            * <p>
893            * 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 PhoneModelImpl}. 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.
894            * </p>
895            *
896            * @param companyId the company ID
897            * @param classNameId the class name ID
898            * @param classPK the class p k
899            * @param primary the primary
900            * @param start the lower bound of the range of phones
901            * @param end the upper bound of the range of phones (not inclusive)
902            * @return the range of matching phones
903            */
904            public java.util.List<Phone> findByC_C_C_P(long companyId,
905                    long classNameId, long classPK, boolean primary, int start, int end);
906    
907            /**
908            * Returns an ordered range of all the phones where companyId = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
909            *
910            * <p>
911            * 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 PhoneModelImpl}. 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.
912            * </p>
913            *
914            * @param companyId the company ID
915            * @param classNameId the class name ID
916            * @param classPK the class p k
917            * @param primary the primary
918            * @param start the lower bound of the range of phones
919            * @param end the upper bound of the range of phones (not inclusive)
920            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
921            * @return the ordered range of matching phones
922            */
923            public java.util.List<Phone> findByC_C_C_P(long companyId,
924                    long classNameId, long classPK, boolean primary, int start, int end,
925                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator);
926    
927            /**
928            * Returns an ordered range of all the phones where companyId = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
929            *
930            * <p>
931            * 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 PhoneModelImpl}. 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.
932            * </p>
933            *
934            * @param companyId the company ID
935            * @param classNameId the class name ID
936            * @param classPK the class p k
937            * @param primary the primary
938            * @param start the lower bound of the range of phones
939            * @param end the upper bound of the range of phones (not inclusive)
940            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
941            * @param retrieveFromCache whether to retrieve from the finder cache
942            * @return the ordered range of matching phones
943            */
944            public java.util.List<Phone> findByC_C_C_P(long companyId,
945                    long classNameId, long classPK, boolean primary, int start, int end,
946                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator,
947                    boolean retrieveFromCache);
948    
949            /**
950            * Returns the first phone in the ordered set where companyId = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
951            *
952            * @param companyId the company ID
953            * @param classNameId the class name ID
954            * @param classPK the class p k
955            * @param primary the primary
956            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
957            * @return the first matching phone
958            * @throws NoSuchPhoneException if a matching phone could not be found
959            */
960            public Phone findByC_C_C_P_First(long companyId, long classNameId,
961                    long classPK, boolean primary,
962                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator)
963                    throws com.liferay.portal.exception.NoSuchPhoneException;
964    
965            /**
966            * Returns the first phone in the ordered set where companyId = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
967            *
968            * @param companyId the company ID
969            * @param classNameId the class name ID
970            * @param classPK the class p k
971            * @param primary the primary
972            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
973            * @return the first matching phone, or <code>null</code> if a matching phone could not be found
974            */
975            public Phone fetchByC_C_C_P_First(long companyId, long classNameId,
976                    long classPK, boolean primary,
977                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator);
978    
979            /**
980            * Returns the last phone in the ordered set where companyId = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
981            *
982            * @param companyId the company ID
983            * @param classNameId the class name ID
984            * @param classPK the class p k
985            * @param primary the primary
986            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
987            * @return the last matching phone
988            * @throws NoSuchPhoneException if a matching phone could not be found
989            */
990            public Phone findByC_C_C_P_Last(long companyId, long classNameId,
991                    long classPK, boolean primary,
992                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator)
993                    throws com.liferay.portal.exception.NoSuchPhoneException;
994    
995            /**
996            * Returns the last phone in the ordered set where companyId = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
997            *
998            * @param companyId the company ID
999            * @param classNameId the class name ID
1000            * @param classPK the class p k
1001            * @param primary the primary
1002            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1003            * @return the last matching phone, or <code>null</code> if a matching phone could not be found
1004            */
1005            public Phone fetchByC_C_C_P_Last(long companyId, long classNameId,
1006                    long classPK, boolean primary,
1007                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator);
1008    
1009            /**
1010            * Returns the phones before and after the current phone in the ordered set where companyId = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
1011            *
1012            * @param phoneId the primary key of the current phone
1013            * @param companyId the company ID
1014            * @param classNameId the class name ID
1015            * @param classPK the class p k
1016            * @param primary the primary
1017            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1018            * @return the previous, current, and next phone
1019            * @throws NoSuchPhoneException if a phone with the primary key could not be found
1020            */
1021            public Phone[] findByC_C_C_P_PrevAndNext(long phoneId, long companyId,
1022                    long classNameId, long classPK, boolean primary,
1023                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator)
1024                    throws com.liferay.portal.exception.NoSuchPhoneException;
1025    
1026            /**
1027            * Removes all the phones where companyId = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63; from the database.
1028            *
1029            * @param companyId the company ID
1030            * @param classNameId the class name ID
1031            * @param classPK the class p k
1032            * @param primary the primary
1033            */
1034            public void removeByC_C_C_P(long companyId, long classNameId, long classPK,
1035                    boolean primary);
1036    
1037            /**
1038            * Returns the number of phones where companyId = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
1039            *
1040            * @param companyId the company ID
1041            * @param classNameId the class name ID
1042            * @param classPK the class p k
1043            * @param primary the primary
1044            * @return the number of matching phones
1045            */
1046            public int countByC_C_C_P(long companyId, long classNameId, long classPK,
1047                    boolean primary);
1048    
1049            /**
1050            * Caches the phone in the entity cache if it is enabled.
1051            *
1052            * @param phone the phone
1053            */
1054            public void cacheResult(Phone phone);
1055    
1056            /**
1057            * Caches the phones in the entity cache if it is enabled.
1058            *
1059            * @param phones the phones
1060            */
1061            public void cacheResult(java.util.List<Phone> phones);
1062    
1063            /**
1064            * Creates a new phone with the primary key. Does not add the phone to the database.
1065            *
1066            * @param phoneId the primary key for the new phone
1067            * @return the new phone
1068            */
1069            public Phone create(long phoneId);
1070    
1071            /**
1072            * Removes the phone with the primary key from the database. Also notifies the appropriate model listeners.
1073            *
1074            * @param phoneId the primary key of the phone
1075            * @return the phone that was removed
1076            * @throws NoSuchPhoneException if a phone with the primary key could not be found
1077            */
1078            public Phone remove(long phoneId)
1079                    throws com.liferay.portal.exception.NoSuchPhoneException;
1080    
1081            public Phone updateImpl(Phone phone);
1082    
1083            /**
1084            * Returns the phone with the primary key or throws a {@link NoSuchPhoneException} if it could not be found.
1085            *
1086            * @param phoneId the primary key of the phone
1087            * @return the phone
1088            * @throws NoSuchPhoneException if a phone with the primary key could not be found
1089            */
1090            public Phone findByPrimaryKey(long phoneId)
1091                    throws com.liferay.portal.exception.NoSuchPhoneException;
1092    
1093            /**
1094            * Returns the phone with the primary key or returns <code>null</code> if it could not be found.
1095            *
1096            * @param phoneId the primary key of the phone
1097            * @return the phone, or <code>null</code> if a phone with the primary key could not be found
1098            */
1099            public Phone fetchByPrimaryKey(long phoneId);
1100    
1101            @Override
1102            public java.util.Map<java.io.Serializable, Phone> fetchByPrimaryKeys(
1103                    java.util.Set<java.io.Serializable> primaryKeys);
1104    
1105            /**
1106            * Returns all the phones.
1107            *
1108            * @return the phones
1109            */
1110            public java.util.List<Phone> findAll();
1111    
1112            /**
1113            * Returns a range of all the phones.
1114            *
1115            * <p>
1116            * 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 PhoneModelImpl}. 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.
1117            * </p>
1118            *
1119            * @param start the lower bound of the range of phones
1120            * @param end the upper bound of the range of phones (not inclusive)
1121            * @return the range of phones
1122            */
1123            public java.util.List<Phone> findAll(int start, int end);
1124    
1125            /**
1126            * Returns an ordered range of all the phones.
1127            *
1128            * <p>
1129            * 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 PhoneModelImpl}. 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.
1130            * </p>
1131            *
1132            * @param start the lower bound of the range of phones
1133            * @param end the upper bound of the range of phones (not inclusive)
1134            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1135            * @return the ordered range of phones
1136            */
1137            public java.util.List<Phone> findAll(int start, int end,
1138                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator);
1139    
1140            /**
1141            * Returns an ordered range of all the phones.
1142            *
1143            * <p>
1144            * 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 PhoneModelImpl}. 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.
1145            * </p>
1146            *
1147            * @param start the lower bound of the range of phones
1148            * @param end the upper bound of the range of phones (not inclusive)
1149            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1150            * @param retrieveFromCache whether to retrieve from the finder cache
1151            * @return the ordered range of phones
1152            */
1153            public java.util.List<Phone> findAll(int start, int end,
1154                    com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator,
1155                    boolean retrieveFromCache);
1156    
1157            /**
1158            * Removes all the phones from the database.
1159            */
1160            public void removeAll();
1161    
1162            /**
1163            * Returns the number of phones.
1164            *
1165            * @return the number of phones
1166            */
1167            public int countAll();
1168    
1169            @Override
1170            public java.util.Set<java.lang.String> getBadColumnNames();
1171    }