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