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