001 /** 002 * Copyright (c) 2000-present Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portal.kernel.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.kernel.exception.NoSuchRepositoryEntryException; 020 import com.liferay.portal.kernel.model.RepositoryEntry; 021 022 /** 023 * The persistence interface for the repository entry 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.RepositoryEntryPersistenceImpl 031 * @see RepositoryEntryUtil 032 * @generated 033 */ 034 @ProviderType 035 public interface RepositoryEntryPersistence extends BasePersistence<RepositoryEntry> { 036 /* 037 * NOTE FOR DEVELOPERS: 038 * 039 * Never modify or reference this interface directly. Always use {@link RepositoryEntryUtil} to access the repository entry persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 040 */ 041 042 /** 043 * Returns all the repository entries where uuid = ?. 044 * 045 * @param uuid the uuid 046 * @return the matching repository entries 047 */ 048 public java.util.List<RepositoryEntry> findByUuid(java.lang.String uuid); 049 050 /** 051 * Returns a range of all the repository entries 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 RepositoryEntryModelImpl}. 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 repository entries 059 * @param end the upper bound of the range of repository entries (not inclusive) 060 * @return the range of matching repository entries 061 */ 062 public java.util.List<RepositoryEntry> findByUuid(java.lang.String uuid, 063 int start, int end); 064 065 /** 066 * Returns an ordered range of all the repository entries 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 RepositoryEntryModelImpl}. 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 repository entries 074 * @param end the upper bound of the range of repository entries (not inclusive) 075 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 076 * @return the ordered range of matching repository entries 077 */ 078 public java.util.List<RepositoryEntry> findByUuid(java.lang.String uuid, 079 int start, int end, 080 com.liferay.portal.kernel.util.OrderByComparator<RepositoryEntry> orderByComparator); 081 082 /** 083 * Returns an ordered range of all the repository entries 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 RepositoryEntryModelImpl}. 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 repository entries 091 * @param end the upper bound of the range of repository entries (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 repository entries 095 */ 096 public java.util.List<RepositoryEntry> findByUuid(java.lang.String uuid, 097 int start, int end, 098 com.liferay.portal.kernel.util.OrderByComparator<RepositoryEntry> orderByComparator, 099 boolean retrieveFromCache); 100 101 /** 102 * Returns the first repository entry 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 repository entry 107 * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found 108 */ 109 public RepositoryEntry findByUuid_First(java.lang.String uuid, 110 com.liferay.portal.kernel.util.OrderByComparator<RepositoryEntry> orderByComparator) 111 throws NoSuchRepositoryEntryException; 112 113 /** 114 * Returns the first repository entry 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 repository entry, or <code>null</code> if a matching repository entry could not be found 119 */ 120 public RepositoryEntry fetchByUuid_First(java.lang.String uuid, 121 com.liferay.portal.kernel.util.OrderByComparator<RepositoryEntry> orderByComparator); 122 123 /** 124 * Returns the last repository entry 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 repository entry 129 * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found 130 */ 131 public RepositoryEntry findByUuid_Last(java.lang.String uuid, 132 com.liferay.portal.kernel.util.OrderByComparator<RepositoryEntry> orderByComparator) 133 throws NoSuchRepositoryEntryException; 134 135 /** 136 * Returns the last repository entry 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 repository entry, or <code>null</code> if a matching repository entry could not be found 141 */ 142 public RepositoryEntry fetchByUuid_Last(java.lang.String uuid, 143 com.liferay.portal.kernel.util.OrderByComparator<RepositoryEntry> orderByComparator); 144 145 /** 146 * Returns the repository entries before and after the current repository entry in the ordered set where uuid = ?. 147 * 148 * @param repositoryEntryId the primary key of the current repository entry 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 repository entry 152 * @throws NoSuchRepositoryEntryException if a repository entry with the primary key could not be found 153 */ 154 public RepositoryEntry[] findByUuid_PrevAndNext(long repositoryEntryId, 155 java.lang.String uuid, 156 com.liferay.portal.kernel.util.OrderByComparator<RepositoryEntry> orderByComparator) 157 throws NoSuchRepositoryEntryException; 158 159 /** 160 * Removes all the repository entries where uuid = ? from the database. 161 * 162 * @param uuid the uuid 163 */ 164 public void removeByUuid(java.lang.String uuid); 165 166 /** 167 * Returns the number of repository entries where uuid = ?. 168 * 169 * @param uuid the uuid 170 * @return the number of matching repository entries 171 */ 172 public int countByUuid(java.lang.String uuid); 173 174 /** 175 * Returns the repository entry where uuid = ? and groupId = ? or throws a {@link NoSuchRepositoryEntryException} if it could not be found. 176 * 177 * @param uuid the uuid 178 * @param groupId the group ID 179 * @return the matching repository entry 180 * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found 181 */ 182 public RepositoryEntry findByUUID_G(java.lang.String uuid, long groupId) 183 throws NoSuchRepositoryEntryException; 184 185 /** 186 * Returns the repository entry where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 187 * 188 * @param uuid the uuid 189 * @param groupId the group ID 190 * @return the matching repository entry, or <code>null</code> if a matching repository entry could not be found 191 */ 192 public RepositoryEntry fetchByUUID_G(java.lang.String uuid, long groupId); 193 194 /** 195 * Returns the repository entry where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 196 * 197 * @param uuid the uuid 198 * @param groupId the group ID 199 * @param retrieveFromCache whether to retrieve from the finder cache 200 * @return the matching repository entry, or <code>null</code> if a matching repository entry could not be found 201 */ 202 public RepositoryEntry fetchByUUID_G(java.lang.String uuid, long groupId, 203 boolean retrieveFromCache); 204 205 /** 206 * Removes the repository entry where uuid = ? and groupId = ? from the database. 207 * 208 * @param uuid the uuid 209 * @param groupId the group ID 210 * @return the repository entry that was removed 211 */ 212 public RepositoryEntry removeByUUID_G(java.lang.String uuid, long groupId) 213 throws NoSuchRepositoryEntryException; 214 215 /** 216 * Returns the number of repository entries where uuid = ? and groupId = ?. 217 * 218 * @param uuid the uuid 219 * @param groupId the group ID 220 * @return the number of matching repository entries 221 */ 222 public int countByUUID_G(java.lang.String uuid, long groupId); 223 224 /** 225 * Returns all the repository entries where uuid = ? and companyId = ?. 226 * 227 * @param uuid the uuid 228 * @param companyId the company ID 229 * @return the matching repository entries 230 */ 231 public java.util.List<RepositoryEntry> findByUuid_C(java.lang.String uuid, 232 long companyId); 233 234 /** 235 * Returns a range of all the repository entries where uuid = ? and companyId = ?. 236 * 237 * <p> 238 * 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 RepositoryEntryModelImpl}. 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. 239 * </p> 240 * 241 * @param uuid the uuid 242 * @param companyId the company ID 243 * @param start the lower bound of the range of repository entries 244 * @param end the upper bound of the range of repository entries (not inclusive) 245 * @return the range of matching repository entries 246 */ 247 public java.util.List<RepositoryEntry> findByUuid_C(java.lang.String uuid, 248 long companyId, int start, int end); 249 250 /** 251 * Returns an ordered range of all the repository entries where uuid = ? and companyId = ?. 252 * 253 * <p> 254 * 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 RepositoryEntryModelImpl}. 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. 255 * </p> 256 * 257 * @param uuid the uuid 258 * @param companyId the company ID 259 * @param start the lower bound of the range of repository entries 260 * @param end the upper bound of the range of repository entries (not inclusive) 261 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 262 * @return the ordered range of matching repository entries 263 */ 264 public java.util.List<RepositoryEntry> findByUuid_C(java.lang.String uuid, 265 long companyId, int start, int end, 266 com.liferay.portal.kernel.util.OrderByComparator<RepositoryEntry> orderByComparator); 267 268 /** 269 * Returns an ordered range of all the repository entries where uuid = ? and companyId = ?. 270 * 271 * <p> 272 * 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 RepositoryEntryModelImpl}. 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. 273 * </p> 274 * 275 * @param uuid the uuid 276 * @param companyId the company ID 277 * @param start the lower bound of the range of repository entries 278 * @param end the upper bound of the range of repository entries (not inclusive) 279 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 280 * @param retrieveFromCache whether to retrieve from the finder cache 281 * @return the ordered range of matching repository entries 282 */ 283 public java.util.List<RepositoryEntry> findByUuid_C(java.lang.String uuid, 284 long companyId, int start, int end, 285 com.liferay.portal.kernel.util.OrderByComparator<RepositoryEntry> orderByComparator, 286 boolean retrieveFromCache); 287 288 /** 289 * Returns the first repository entry in the ordered set where uuid = ? and companyId = ?. 290 * 291 * @param uuid the uuid 292 * @param companyId the company ID 293 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 294 * @return the first matching repository entry 295 * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found 296 */ 297 public RepositoryEntry findByUuid_C_First(java.lang.String uuid, 298 long companyId, 299 com.liferay.portal.kernel.util.OrderByComparator<RepositoryEntry> orderByComparator) 300 throws NoSuchRepositoryEntryException; 301 302 /** 303 * Returns the first repository entry in the ordered set where uuid = ? and companyId = ?. 304 * 305 * @param uuid the uuid 306 * @param companyId the company ID 307 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 308 * @return the first matching repository entry, or <code>null</code> if a matching repository entry could not be found 309 */ 310 public RepositoryEntry fetchByUuid_C_First(java.lang.String uuid, 311 long companyId, 312 com.liferay.portal.kernel.util.OrderByComparator<RepositoryEntry> orderByComparator); 313 314 /** 315 * Returns the last repository entry in the ordered set where uuid = ? and companyId = ?. 316 * 317 * @param uuid the uuid 318 * @param companyId the company ID 319 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 320 * @return the last matching repository entry 321 * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found 322 */ 323 public RepositoryEntry findByUuid_C_Last(java.lang.String uuid, 324 long companyId, 325 com.liferay.portal.kernel.util.OrderByComparator<RepositoryEntry> orderByComparator) 326 throws NoSuchRepositoryEntryException; 327 328 /** 329 * Returns the last repository entry in the ordered set where uuid = ? and companyId = ?. 330 * 331 * @param uuid the uuid 332 * @param companyId the company ID 333 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 334 * @return the last matching repository entry, or <code>null</code> if a matching repository entry could not be found 335 */ 336 public RepositoryEntry fetchByUuid_C_Last(java.lang.String uuid, 337 long companyId, 338 com.liferay.portal.kernel.util.OrderByComparator<RepositoryEntry> orderByComparator); 339 340 /** 341 * Returns the repository entries before and after the current repository entry in the ordered set where uuid = ? and companyId = ?. 342 * 343 * @param repositoryEntryId the primary key of the current repository entry 344 * @param uuid the uuid 345 * @param companyId the company ID 346 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 347 * @return the previous, current, and next repository entry 348 * @throws NoSuchRepositoryEntryException if a repository entry with the primary key could not be found 349 */ 350 public RepositoryEntry[] findByUuid_C_PrevAndNext(long repositoryEntryId, 351 java.lang.String uuid, long companyId, 352 com.liferay.portal.kernel.util.OrderByComparator<RepositoryEntry> orderByComparator) 353 throws NoSuchRepositoryEntryException; 354 355 /** 356 * Removes all the repository entries where uuid = ? and companyId = ? from the database. 357 * 358 * @param uuid the uuid 359 * @param companyId the company ID 360 */ 361 public void removeByUuid_C(java.lang.String uuid, long companyId); 362 363 /** 364 * Returns the number of repository entries where uuid = ? and companyId = ?. 365 * 366 * @param uuid the uuid 367 * @param companyId the company ID 368 * @return the number of matching repository entries 369 */ 370 public int countByUuid_C(java.lang.String uuid, long companyId); 371 372 /** 373 * Returns all the repository entries where repositoryId = ?. 374 * 375 * @param repositoryId the repository ID 376 * @return the matching repository entries 377 */ 378 public java.util.List<RepositoryEntry> findByRepositoryId(long repositoryId); 379 380 /** 381 * Returns a range of all the repository entries where repositoryId = ?. 382 * 383 * <p> 384 * 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 RepositoryEntryModelImpl}. 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. 385 * </p> 386 * 387 * @param repositoryId the repository ID 388 * @param start the lower bound of the range of repository entries 389 * @param end the upper bound of the range of repository entries (not inclusive) 390 * @return the range of matching repository entries 391 */ 392 public java.util.List<RepositoryEntry> findByRepositoryId( 393 long repositoryId, int start, int end); 394 395 /** 396 * Returns an ordered range of all the repository entries where repositoryId = ?. 397 * 398 * <p> 399 * 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 RepositoryEntryModelImpl}. 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. 400 * </p> 401 * 402 * @param repositoryId the repository ID 403 * @param start the lower bound of the range of repository entries 404 * @param end the upper bound of the range of repository entries (not inclusive) 405 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 406 * @return the ordered range of matching repository entries 407 */ 408 public java.util.List<RepositoryEntry> findByRepositoryId( 409 long repositoryId, int start, int end, 410 com.liferay.portal.kernel.util.OrderByComparator<RepositoryEntry> orderByComparator); 411 412 /** 413 * Returns an ordered range of all the repository entries where repositoryId = ?. 414 * 415 * <p> 416 * 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 RepositoryEntryModelImpl}. 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. 417 * </p> 418 * 419 * @param repositoryId the repository ID 420 * @param start the lower bound of the range of repository entries 421 * @param end the upper bound of the range of repository entries (not inclusive) 422 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 423 * @param retrieveFromCache whether to retrieve from the finder cache 424 * @return the ordered range of matching repository entries 425 */ 426 public java.util.List<RepositoryEntry> findByRepositoryId( 427 long repositoryId, int start, int end, 428 com.liferay.portal.kernel.util.OrderByComparator<RepositoryEntry> orderByComparator, 429 boolean retrieveFromCache); 430 431 /** 432 * Returns the first repository entry in the ordered set where repositoryId = ?. 433 * 434 * @param repositoryId the repository ID 435 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 436 * @return the first matching repository entry 437 * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found 438 */ 439 public RepositoryEntry findByRepositoryId_First(long repositoryId, 440 com.liferay.portal.kernel.util.OrderByComparator<RepositoryEntry> orderByComparator) 441 throws NoSuchRepositoryEntryException; 442 443 /** 444 * Returns the first repository entry in the ordered set where repositoryId = ?. 445 * 446 * @param repositoryId the repository ID 447 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 448 * @return the first matching repository entry, or <code>null</code> if a matching repository entry could not be found 449 */ 450 public RepositoryEntry fetchByRepositoryId_First(long repositoryId, 451 com.liferay.portal.kernel.util.OrderByComparator<RepositoryEntry> orderByComparator); 452 453 /** 454 * Returns the last repository entry in the ordered set where repositoryId = ?. 455 * 456 * @param repositoryId the repository ID 457 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 458 * @return the last matching repository entry 459 * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found 460 */ 461 public RepositoryEntry findByRepositoryId_Last(long repositoryId, 462 com.liferay.portal.kernel.util.OrderByComparator<RepositoryEntry> orderByComparator) 463 throws NoSuchRepositoryEntryException; 464 465 /** 466 * Returns the last repository entry in the ordered set where repositoryId = ?. 467 * 468 * @param repositoryId the repository ID 469 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 470 * @return the last matching repository entry, or <code>null</code> if a matching repository entry could not be found 471 */ 472 public RepositoryEntry fetchByRepositoryId_Last(long repositoryId, 473 com.liferay.portal.kernel.util.OrderByComparator<RepositoryEntry> orderByComparator); 474 475 /** 476 * Returns the repository entries before and after the current repository entry in the ordered set where repositoryId = ?. 477 * 478 * @param repositoryEntryId the primary key of the current repository entry 479 * @param repositoryId the repository ID 480 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 481 * @return the previous, current, and next repository entry 482 * @throws NoSuchRepositoryEntryException if a repository entry with the primary key could not be found 483 */ 484 public RepositoryEntry[] findByRepositoryId_PrevAndNext( 485 long repositoryEntryId, long repositoryId, 486 com.liferay.portal.kernel.util.OrderByComparator<RepositoryEntry> orderByComparator) 487 throws NoSuchRepositoryEntryException; 488 489 /** 490 * Removes all the repository entries where repositoryId = ? from the database. 491 * 492 * @param repositoryId the repository ID 493 */ 494 public void removeByRepositoryId(long repositoryId); 495 496 /** 497 * Returns the number of repository entries where repositoryId = ?. 498 * 499 * @param repositoryId the repository ID 500 * @return the number of matching repository entries 501 */ 502 public int countByRepositoryId(long repositoryId); 503 504 /** 505 * Returns the repository entry where repositoryId = ? and mappedId = ? or throws a {@link NoSuchRepositoryEntryException} if it could not be found. 506 * 507 * @param repositoryId the repository ID 508 * @param mappedId the mapped ID 509 * @return the matching repository entry 510 * @throws NoSuchRepositoryEntryException if a matching repository entry could not be found 511 */ 512 public RepositoryEntry findByR_M(long repositoryId, 513 java.lang.String mappedId) throws NoSuchRepositoryEntryException; 514 515 /** 516 * Returns the repository entry where repositoryId = ? and mappedId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 517 * 518 * @param repositoryId the repository ID 519 * @param mappedId the mapped ID 520 * @return the matching repository entry, or <code>null</code> if a matching repository entry could not be found 521 */ 522 public RepositoryEntry fetchByR_M(long repositoryId, 523 java.lang.String mappedId); 524 525 /** 526 * Returns the repository entry where repositoryId = ? and mappedId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 527 * 528 * @param repositoryId the repository ID 529 * @param mappedId the mapped ID 530 * @param retrieveFromCache whether to retrieve from the finder cache 531 * @return the matching repository entry, or <code>null</code> if a matching repository entry could not be found 532 */ 533 public RepositoryEntry fetchByR_M(long repositoryId, 534 java.lang.String mappedId, boolean retrieveFromCache); 535 536 /** 537 * Removes the repository entry where repositoryId = ? and mappedId = ? from the database. 538 * 539 * @param repositoryId the repository ID 540 * @param mappedId the mapped ID 541 * @return the repository entry that was removed 542 */ 543 public RepositoryEntry removeByR_M(long repositoryId, 544 java.lang.String mappedId) throws NoSuchRepositoryEntryException; 545 546 /** 547 * Returns the number of repository entries where repositoryId = ? and mappedId = ?. 548 * 549 * @param repositoryId the repository ID 550 * @param mappedId the mapped ID 551 * @return the number of matching repository entries 552 */ 553 public int countByR_M(long repositoryId, java.lang.String mappedId); 554 555 /** 556 * Caches the repository entry in the entity cache if it is enabled. 557 * 558 * @param repositoryEntry the repository entry 559 */ 560 public void cacheResult(RepositoryEntry repositoryEntry); 561 562 /** 563 * Caches the repository entries in the entity cache if it is enabled. 564 * 565 * @param repositoryEntries the repository entries 566 */ 567 public void cacheResult(java.util.List<RepositoryEntry> repositoryEntries); 568 569 /** 570 * Creates a new repository entry with the primary key. Does not add the repository entry to the database. 571 * 572 * @param repositoryEntryId the primary key for the new repository entry 573 * @return the new repository entry 574 */ 575 public RepositoryEntry create(long repositoryEntryId); 576 577 /** 578 * Removes the repository entry with the primary key from the database. Also notifies the appropriate model listeners. 579 * 580 * @param repositoryEntryId the primary key of the repository entry 581 * @return the repository entry that was removed 582 * @throws NoSuchRepositoryEntryException if a repository entry with the primary key could not be found 583 */ 584 public RepositoryEntry remove(long repositoryEntryId) 585 throws NoSuchRepositoryEntryException; 586 587 public RepositoryEntry updateImpl(RepositoryEntry repositoryEntry); 588 589 /** 590 * Returns the repository entry with the primary key or throws a {@link NoSuchRepositoryEntryException} if it could not be found. 591 * 592 * @param repositoryEntryId the primary key of the repository entry 593 * @return the repository entry 594 * @throws NoSuchRepositoryEntryException if a repository entry with the primary key could not be found 595 */ 596 public RepositoryEntry findByPrimaryKey(long repositoryEntryId) 597 throws NoSuchRepositoryEntryException; 598 599 /** 600 * Returns the repository entry with the primary key or returns <code>null</code> if it could not be found. 601 * 602 * @param repositoryEntryId the primary key of the repository entry 603 * @return the repository entry, or <code>null</code> if a repository entry with the primary key could not be found 604 */ 605 public RepositoryEntry fetchByPrimaryKey(long repositoryEntryId); 606 607 @Override 608 public java.util.Map<java.io.Serializable, RepositoryEntry> fetchByPrimaryKeys( 609 java.util.Set<java.io.Serializable> primaryKeys); 610 611 /** 612 * Returns all the repository entries. 613 * 614 * @return the repository entries 615 */ 616 public java.util.List<RepositoryEntry> findAll(); 617 618 /** 619 * Returns a range of all the repository entries. 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 RepositoryEntryModelImpl}. 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 start the lower bound of the range of repository entries 626 * @param end the upper bound of the range of repository entries (not inclusive) 627 * @return the range of repository entries 628 */ 629 public java.util.List<RepositoryEntry> findAll(int start, int end); 630 631 /** 632 * Returns an ordered range of all the repository entries. 633 * 634 * <p> 635 * 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 RepositoryEntryModelImpl}. 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. 636 * </p> 637 * 638 * @param start the lower bound of the range of repository entries 639 * @param end the upper bound of the range of repository entries (not inclusive) 640 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 641 * @return the ordered range of repository entries 642 */ 643 public java.util.List<RepositoryEntry> findAll(int start, int end, 644 com.liferay.portal.kernel.util.OrderByComparator<RepositoryEntry> orderByComparator); 645 646 /** 647 * Returns an ordered range of all the repository entries. 648 * 649 * <p> 650 * 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 RepositoryEntryModelImpl}. 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. 651 * </p> 652 * 653 * @param start the lower bound of the range of repository entries 654 * @param end the upper bound of the range of repository entries (not inclusive) 655 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 656 * @param retrieveFromCache whether to retrieve from the finder cache 657 * @return the ordered range of repository entries 658 */ 659 public java.util.List<RepositoryEntry> findAll(int start, int end, 660 com.liferay.portal.kernel.util.OrderByComparator<RepositoryEntry> orderByComparator, 661 boolean retrieveFromCache); 662 663 /** 664 * Removes all the repository entries from the database. 665 */ 666 public void removeAll(); 667 668 /** 669 * Returns the number of repository entries. 670 * 671 * @return the number of repository entries 672 */ 673 public int countAll(); 674 675 @Override 676 public java.util.Set<java.lang.String> getBadColumnNames(); 677 }