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