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