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