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