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.exception.NoSuchAddressException; 020 import com.liferay.portal.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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ? 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 = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ?. 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 = ? and companyId = ? 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 = ? and companyId = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ? 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ?. 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 = ? 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 = ?. 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 = ? and classNameId = ?. 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 = ? and classNameId = ?. 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 = ? and classNameId = ?. 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 = ? and classNameId = ?. 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 = ? and classNameId = ?. 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 = ? and classNameId = ?. 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 = ? and classNameId = ?. 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 = ? and classNameId = ?. 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 = ? and classNameId = ?. 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 = ? and classNameId = ? 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 = ? and classNameId = ?. 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 = ? and classNameId = ? and classPK = ?. 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 = ? and classNameId = ? and classPK = ?. 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 = ? and classNameId = ? and classPK = ?. 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 = ? and classNameId = ? and classPK = ?. 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 = ? and classNameId = ? and classPK = ?. 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 = ? and classNameId = ? and classPK = ?. 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 = ? and classNameId = ? and classPK = ?. 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 = ? and classNameId = ? and classPK = ?. 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 = ? and classNameId = ? and classPK = ?. 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 = ? and classNameId = ? and classPK = ? 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 = ? and classNameId = ? and classPK = ?. 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 = ? and classNameId = ? and classPK = ? and mailing = ?. 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 = ? and classNameId = ? and classPK = ? and mailing = ?. 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 = ? and classNameId = ? and classPK = ? and mailing = ?. 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 = ? and classNameId = ? and classPK = ? and mailing = ?. 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 = ? and classNameId = ? and classPK = ? and mailing = ?. 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 = ? and classNameId = ? and classPK = ? and mailing = ?. 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 = ? and classNameId = ? and classPK = ? and mailing = ?. 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 = ? and classNameId = ? and classPK = ? and mailing = ?. 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 = ? and classNameId = ? and classPK = ? and mailing = ?. 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 = ? and classNameId = ? and classPK = ? and mailing = ? 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 = ? and classNameId = ? and classPK = ? and mailing = ?. 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 = ? and classNameId = ? and classPK = ? and primary = ?. 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 = ? and classNameId = ? and classPK = ? and primary = ?. 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 = ? and classNameId = ? and classPK = ? and primary = ?. 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 = ? and classNameId = ? and classPK = ? and primary = ?. 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 = ? and classNameId = ? and classPK = ? and primary = ?. 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 = ? and classNameId = ? and classPK = ? and primary = ?. 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 = ? and classNameId = ? and classPK = ? and primary = ?. 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 = ? and classNameId = ? and classPK = ? and primary = ?. 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 = ? and classNameId = ? and classPK = ? and primary = ?. 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 = ? and classNameId = ? and classPK = ? and primary = ? 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 = ? and classNameId = ? and classPK = ? and primary = ?. 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 }