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.document.library.kernel.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.document.library.kernel.exception.NoSuchFileVersionException; 020 import com.liferay.document.library.kernel.model.DLFileVersion; 021 022 import com.liferay.portal.kernel.service.persistence.BasePersistence; 023 024 /** 025 * The persistence interface for the document library file version service. 026 * 027 * <p> 028 * Caching information and settings can be found in <code>portal.properties</code> 029 * </p> 030 * 031 * @author Brian Wing Shun Chan 032 * @see com.liferay.portlet.documentlibrary.service.persistence.impl.DLFileVersionPersistenceImpl 033 * @see DLFileVersionUtil 034 * @generated 035 */ 036 @ProviderType 037 public interface DLFileVersionPersistence extends BasePersistence<DLFileVersion> { 038 /* 039 * NOTE FOR DEVELOPERS: 040 * 041 * Never modify or reference this interface directly. Always use {@link DLFileVersionUtil} to access the document library file version persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 042 */ 043 044 /** 045 * Returns all the document library file versions where uuid = ?. 046 * 047 * @param uuid the uuid 048 * @return the matching document library file versions 049 */ 050 public java.util.List<DLFileVersion> findByUuid(java.lang.String uuid); 051 052 /** 053 * Returns a range of all the document library file versions where uuid = ?. 054 * 055 * <p> 056 * 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 DLFileVersionModelImpl}. 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. 057 * </p> 058 * 059 * @param uuid the uuid 060 * @param start the lower bound of the range of document library file versions 061 * @param end the upper bound of the range of document library file versions (not inclusive) 062 * @return the range of matching document library file versions 063 */ 064 public java.util.List<DLFileVersion> findByUuid(java.lang.String uuid, 065 int start, int end); 066 067 /** 068 * Returns an ordered range of all the document library file versions where uuid = ?. 069 * 070 * <p> 071 * 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 DLFileVersionModelImpl}. 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. 072 * </p> 073 * 074 * @param uuid the uuid 075 * @param start the lower bound of the range of document library file versions 076 * @param end the upper bound of the range of document library file versions (not inclusive) 077 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 078 * @return the ordered range of matching document library file versions 079 */ 080 public java.util.List<DLFileVersion> findByUuid(java.lang.String uuid, 081 int start, int end, 082 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator); 083 084 /** 085 * Returns an ordered range of all the document library file versions where uuid = ?. 086 * 087 * <p> 088 * 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 DLFileVersionModelImpl}. 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. 089 * </p> 090 * 091 * @param uuid the uuid 092 * @param start the lower bound of the range of document library file versions 093 * @param end the upper bound of the range of document library file versions (not inclusive) 094 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 095 * @param retrieveFromCache whether to retrieve from the finder cache 096 * @return the ordered range of matching document library file versions 097 */ 098 public java.util.List<DLFileVersion> findByUuid(java.lang.String uuid, 099 int start, int end, 100 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator, 101 boolean retrieveFromCache); 102 103 /** 104 * Returns the first document library file version in the ordered set where uuid = ?. 105 * 106 * @param uuid the uuid 107 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 108 * @return the first matching document library file version 109 * @throws NoSuchFileVersionException if a matching document library file version could not be found 110 */ 111 public DLFileVersion findByUuid_First(java.lang.String uuid, 112 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator) 113 throws NoSuchFileVersionException; 114 115 /** 116 * Returns the first document library file version in the ordered set where uuid = ?. 117 * 118 * @param uuid the uuid 119 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 120 * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found 121 */ 122 public DLFileVersion fetchByUuid_First(java.lang.String uuid, 123 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator); 124 125 /** 126 * Returns the last document library file version in the ordered set where uuid = ?. 127 * 128 * @param uuid the uuid 129 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 130 * @return the last matching document library file version 131 * @throws NoSuchFileVersionException if a matching document library file version could not be found 132 */ 133 public DLFileVersion findByUuid_Last(java.lang.String uuid, 134 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator) 135 throws NoSuchFileVersionException; 136 137 /** 138 * Returns the last document library file version in the ordered set where uuid = ?. 139 * 140 * @param uuid the uuid 141 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 142 * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found 143 */ 144 public DLFileVersion fetchByUuid_Last(java.lang.String uuid, 145 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator); 146 147 /** 148 * Returns the document library file versions before and after the current document library file version in the ordered set where uuid = ?. 149 * 150 * @param fileVersionId the primary key of the current document library file version 151 * @param uuid the uuid 152 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 153 * @return the previous, current, and next document library file version 154 * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found 155 */ 156 public DLFileVersion[] findByUuid_PrevAndNext(long fileVersionId, 157 java.lang.String uuid, 158 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator) 159 throws NoSuchFileVersionException; 160 161 /** 162 * Removes all the document library file versions where uuid = ? from the database. 163 * 164 * @param uuid the uuid 165 */ 166 public void removeByUuid(java.lang.String uuid); 167 168 /** 169 * Returns the number of document library file versions where uuid = ?. 170 * 171 * @param uuid the uuid 172 * @return the number of matching document library file versions 173 */ 174 public int countByUuid(java.lang.String uuid); 175 176 /** 177 * Returns the document library file version where uuid = ? and groupId = ? or throws a {@link NoSuchFileVersionException} if it could not be found. 178 * 179 * @param uuid the uuid 180 * @param groupId the group ID 181 * @return the matching document library file version 182 * @throws NoSuchFileVersionException if a matching document library file version could not be found 183 */ 184 public DLFileVersion findByUUID_G(java.lang.String uuid, long groupId) 185 throws NoSuchFileVersionException; 186 187 /** 188 * Returns the document library file version where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 189 * 190 * @param uuid the uuid 191 * @param groupId the group ID 192 * @return the matching document library file version, or <code>null</code> if a matching document library file version could not be found 193 */ 194 public DLFileVersion fetchByUUID_G(java.lang.String uuid, long groupId); 195 196 /** 197 * Returns the document library file version where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 198 * 199 * @param uuid the uuid 200 * @param groupId the group ID 201 * @param retrieveFromCache whether to retrieve from the finder cache 202 * @return the matching document library file version, or <code>null</code> if a matching document library file version could not be found 203 */ 204 public DLFileVersion fetchByUUID_G(java.lang.String uuid, long groupId, 205 boolean retrieveFromCache); 206 207 /** 208 * Removes the document library file version where uuid = ? and groupId = ? from the database. 209 * 210 * @param uuid the uuid 211 * @param groupId the group ID 212 * @return the document library file version that was removed 213 */ 214 public DLFileVersion removeByUUID_G(java.lang.String uuid, long groupId) 215 throws NoSuchFileVersionException; 216 217 /** 218 * Returns the number of document library file versions where uuid = ? and groupId = ?. 219 * 220 * @param uuid the uuid 221 * @param groupId the group ID 222 * @return the number of matching document library file versions 223 */ 224 public int countByUUID_G(java.lang.String uuid, long groupId); 225 226 /** 227 * Returns all the document library file versions where uuid = ? and companyId = ?. 228 * 229 * @param uuid the uuid 230 * @param companyId the company ID 231 * @return the matching document library file versions 232 */ 233 public java.util.List<DLFileVersion> findByUuid_C(java.lang.String uuid, 234 long companyId); 235 236 /** 237 * Returns a range of all the document library file versions where uuid = ? and companyId = ?. 238 * 239 * <p> 240 * 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 DLFileVersionModelImpl}. 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. 241 * </p> 242 * 243 * @param uuid the uuid 244 * @param companyId the company ID 245 * @param start the lower bound of the range of document library file versions 246 * @param end the upper bound of the range of document library file versions (not inclusive) 247 * @return the range of matching document library file versions 248 */ 249 public java.util.List<DLFileVersion> findByUuid_C(java.lang.String uuid, 250 long companyId, int start, int end); 251 252 /** 253 * Returns an ordered range of all the document library file versions where uuid = ? and companyId = ?. 254 * 255 * <p> 256 * 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 DLFileVersionModelImpl}. 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. 257 * </p> 258 * 259 * @param uuid the uuid 260 * @param companyId the company ID 261 * @param start the lower bound of the range of document library file versions 262 * @param end the upper bound of the range of document library file versions (not inclusive) 263 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 264 * @return the ordered range of matching document library file versions 265 */ 266 public java.util.List<DLFileVersion> findByUuid_C(java.lang.String uuid, 267 long companyId, int start, int end, 268 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator); 269 270 /** 271 * Returns an ordered range of all the document library file versions where uuid = ? and companyId = ?. 272 * 273 * <p> 274 * 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 DLFileVersionModelImpl}. 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. 275 * </p> 276 * 277 * @param uuid the uuid 278 * @param companyId the company ID 279 * @param start the lower bound of the range of document library file versions 280 * @param end the upper bound of the range of document library file versions (not inclusive) 281 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 282 * @param retrieveFromCache whether to retrieve from the finder cache 283 * @return the ordered range of matching document library file versions 284 */ 285 public java.util.List<DLFileVersion> findByUuid_C(java.lang.String uuid, 286 long companyId, int start, int end, 287 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator, 288 boolean retrieveFromCache); 289 290 /** 291 * Returns the first document library file version in the ordered set where uuid = ? and companyId = ?. 292 * 293 * @param uuid the uuid 294 * @param companyId the company ID 295 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 296 * @return the first matching document library file version 297 * @throws NoSuchFileVersionException if a matching document library file version could not be found 298 */ 299 public DLFileVersion findByUuid_C_First(java.lang.String uuid, 300 long companyId, 301 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator) 302 throws NoSuchFileVersionException; 303 304 /** 305 * Returns the first document library file version in the ordered set where uuid = ? and companyId = ?. 306 * 307 * @param uuid the uuid 308 * @param companyId the company ID 309 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 310 * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found 311 */ 312 public DLFileVersion fetchByUuid_C_First(java.lang.String uuid, 313 long companyId, 314 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator); 315 316 /** 317 * Returns the last document library file version in the ordered set where uuid = ? and companyId = ?. 318 * 319 * @param uuid the uuid 320 * @param companyId the company ID 321 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 322 * @return the last matching document library file version 323 * @throws NoSuchFileVersionException if a matching document library file version could not be found 324 */ 325 public DLFileVersion findByUuid_C_Last(java.lang.String uuid, 326 long companyId, 327 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator) 328 throws NoSuchFileVersionException; 329 330 /** 331 * Returns the last document library file version in the ordered set where uuid = ? and companyId = ?. 332 * 333 * @param uuid the uuid 334 * @param companyId the company ID 335 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 336 * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found 337 */ 338 public DLFileVersion fetchByUuid_C_Last(java.lang.String uuid, 339 long companyId, 340 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator); 341 342 /** 343 * Returns the document library file versions before and after the current document library file version in the ordered set where uuid = ? and companyId = ?. 344 * 345 * @param fileVersionId the primary key of the current document library file version 346 * @param uuid the uuid 347 * @param companyId the company ID 348 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 349 * @return the previous, current, and next document library file version 350 * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found 351 */ 352 public DLFileVersion[] findByUuid_C_PrevAndNext(long fileVersionId, 353 java.lang.String uuid, long companyId, 354 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator) 355 throws NoSuchFileVersionException; 356 357 /** 358 * Removes all the document library file versions where uuid = ? and companyId = ? from the database. 359 * 360 * @param uuid the uuid 361 * @param companyId the company ID 362 */ 363 public void removeByUuid_C(java.lang.String uuid, long companyId); 364 365 /** 366 * Returns the number of document library file versions where uuid = ? and companyId = ?. 367 * 368 * @param uuid the uuid 369 * @param companyId the company ID 370 * @return the number of matching document library file versions 371 */ 372 public int countByUuid_C(java.lang.String uuid, long companyId); 373 374 /** 375 * Returns all the document library file versions where companyId = ?. 376 * 377 * @param companyId the company ID 378 * @return the matching document library file versions 379 */ 380 public java.util.List<DLFileVersion> findByCompanyId(long companyId); 381 382 /** 383 * Returns a range of all the document library file versions where companyId = ?. 384 * 385 * <p> 386 * 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 DLFileVersionModelImpl}. 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. 387 * </p> 388 * 389 * @param companyId the company ID 390 * @param start the lower bound of the range of document library file versions 391 * @param end the upper bound of the range of document library file versions (not inclusive) 392 * @return the range of matching document library file versions 393 */ 394 public java.util.List<DLFileVersion> findByCompanyId(long companyId, 395 int start, int end); 396 397 /** 398 * Returns an ordered range of all the document library file versions where companyId = ?. 399 * 400 * <p> 401 * 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 DLFileVersionModelImpl}. 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. 402 * </p> 403 * 404 * @param companyId the company ID 405 * @param start the lower bound of the range of document library file versions 406 * @param end the upper bound of the range of document library file versions (not inclusive) 407 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 408 * @return the ordered range of matching document library file versions 409 */ 410 public java.util.List<DLFileVersion> findByCompanyId(long companyId, 411 int start, int end, 412 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator); 413 414 /** 415 * Returns an ordered range of all the document library file versions where companyId = ?. 416 * 417 * <p> 418 * 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 DLFileVersionModelImpl}. 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. 419 * </p> 420 * 421 * @param companyId the company ID 422 * @param start the lower bound of the range of document library file versions 423 * @param end the upper bound of the range of document library file versions (not inclusive) 424 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 425 * @param retrieveFromCache whether to retrieve from the finder cache 426 * @return the ordered range of matching document library file versions 427 */ 428 public java.util.List<DLFileVersion> findByCompanyId(long companyId, 429 int start, int end, 430 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator, 431 boolean retrieveFromCache); 432 433 /** 434 * Returns the first document library file version in the ordered set where companyId = ?. 435 * 436 * @param companyId the company ID 437 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 438 * @return the first matching document library file version 439 * @throws NoSuchFileVersionException if a matching document library file version could not be found 440 */ 441 public DLFileVersion findByCompanyId_First(long companyId, 442 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator) 443 throws NoSuchFileVersionException; 444 445 /** 446 * Returns the first document library file version in the ordered set where companyId = ?. 447 * 448 * @param companyId the company ID 449 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 450 * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found 451 */ 452 public DLFileVersion fetchByCompanyId_First(long companyId, 453 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator); 454 455 /** 456 * Returns the last document library file version in the ordered set where companyId = ?. 457 * 458 * @param companyId the company ID 459 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 460 * @return the last matching document library file version 461 * @throws NoSuchFileVersionException if a matching document library file version could not be found 462 */ 463 public DLFileVersion findByCompanyId_Last(long companyId, 464 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator) 465 throws NoSuchFileVersionException; 466 467 /** 468 * Returns the last document library file version in the ordered set where companyId = ?. 469 * 470 * @param companyId the company ID 471 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 472 * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found 473 */ 474 public DLFileVersion fetchByCompanyId_Last(long companyId, 475 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator); 476 477 /** 478 * Returns the document library file versions before and after the current document library file version in the ordered set where companyId = ?. 479 * 480 * @param fileVersionId the primary key of the current document library file version 481 * @param companyId the company ID 482 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 483 * @return the previous, current, and next document library file version 484 * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found 485 */ 486 public DLFileVersion[] findByCompanyId_PrevAndNext(long fileVersionId, 487 long companyId, 488 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator) 489 throws NoSuchFileVersionException; 490 491 /** 492 * Removes all the document library file versions where companyId = ? from the database. 493 * 494 * @param companyId the company ID 495 */ 496 public void removeByCompanyId(long companyId); 497 498 /** 499 * Returns the number of document library file versions where companyId = ?. 500 * 501 * @param companyId the company ID 502 * @return the number of matching document library file versions 503 */ 504 public int countByCompanyId(long companyId); 505 506 /** 507 * Returns all the document library file versions where fileEntryId = ?. 508 * 509 * @param fileEntryId the file entry ID 510 * @return the matching document library file versions 511 */ 512 public java.util.List<DLFileVersion> findByFileEntryId(long fileEntryId); 513 514 /** 515 * Returns a range of all the document library file versions where fileEntryId = ?. 516 * 517 * <p> 518 * 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 DLFileVersionModelImpl}. 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. 519 * </p> 520 * 521 * @param fileEntryId the file entry ID 522 * @param start the lower bound of the range of document library file versions 523 * @param end the upper bound of the range of document library file versions (not inclusive) 524 * @return the range of matching document library file versions 525 */ 526 public java.util.List<DLFileVersion> findByFileEntryId(long fileEntryId, 527 int start, int end); 528 529 /** 530 * Returns an ordered range of all the document library file versions where fileEntryId = ?. 531 * 532 * <p> 533 * 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 DLFileVersionModelImpl}. 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. 534 * </p> 535 * 536 * @param fileEntryId the file entry ID 537 * @param start the lower bound of the range of document library file versions 538 * @param end the upper bound of the range of document library file versions (not inclusive) 539 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 540 * @return the ordered range of matching document library file versions 541 */ 542 public java.util.List<DLFileVersion> findByFileEntryId(long fileEntryId, 543 int start, int end, 544 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator); 545 546 /** 547 * Returns an ordered range of all the document library file versions where fileEntryId = ?. 548 * 549 * <p> 550 * 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 DLFileVersionModelImpl}. 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. 551 * </p> 552 * 553 * @param fileEntryId the file entry ID 554 * @param start the lower bound of the range of document library file versions 555 * @param end the upper bound of the range of document library file versions (not inclusive) 556 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 557 * @param retrieveFromCache whether to retrieve from the finder cache 558 * @return the ordered range of matching document library file versions 559 */ 560 public java.util.List<DLFileVersion> findByFileEntryId(long fileEntryId, 561 int start, int end, 562 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator, 563 boolean retrieveFromCache); 564 565 /** 566 * Returns the first document library file version in the ordered set where fileEntryId = ?. 567 * 568 * @param fileEntryId the file entry ID 569 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 570 * @return the first matching document library file version 571 * @throws NoSuchFileVersionException if a matching document library file version could not be found 572 */ 573 public DLFileVersion findByFileEntryId_First(long fileEntryId, 574 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator) 575 throws NoSuchFileVersionException; 576 577 /** 578 * Returns the first document library file version in the ordered set where fileEntryId = ?. 579 * 580 * @param fileEntryId the file entry ID 581 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 582 * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found 583 */ 584 public DLFileVersion fetchByFileEntryId_First(long fileEntryId, 585 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator); 586 587 /** 588 * Returns the last document library file version in the ordered set where fileEntryId = ?. 589 * 590 * @param fileEntryId the file entry ID 591 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 592 * @return the last matching document library file version 593 * @throws NoSuchFileVersionException if a matching document library file version could not be found 594 */ 595 public DLFileVersion findByFileEntryId_Last(long fileEntryId, 596 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator) 597 throws NoSuchFileVersionException; 598 599 /** 600 * Returns the last document library file version in the ordered set where fileEntryId = ?. 601 * 602 * @param fileEntryId the file entry ID 603 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 604 * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found 605 */ 606 public DLFileVersion fetchByFileEntryId_Last(long fileEntryId, 607 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator); 608 609 /** 610 * Returns the document library file versions before and after the current document library file version in the ordered set where fileEntryId = ?. 611 * 612 * @param fileVersionId the primary key of the current document library file version 613 * @param fileEntryId the file entry ID 614 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 615 * @return the previous, current, and next document library file version 616 * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found 617 */ 618 public DLFileVersion[] findByFileEntryId_PrevAndNext(long fileVersionId, 619 long fileEntryId, 620 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator) 621 throws NoSuchFileVersionException; 622 623 /** 624 * Removes all the document library file versions where fileEntryId = ? from the database. 625 * 626 * @param fileEntryId the file entry ID 627 */ 628 public void removeByFileEntryId(long fileEntryId); 629 630 /** 631 * Returns the number of document library file versions where fileEntryId = ?. 632 * 633 * @param fileEntryId the file entry ID 634 * @return the number of matching document library file versions 635 */ 636 public int countByFileEntryId(long fileEntryId); 637 638 /** 639 * Returns all the document library file versions where mimeType = ?. 640 * 641 * @param mimeType the mime type 642 * @return the matching document library file versions 643 */ 644 public java.util.List<DLFileVersion> findByMimeType( 645 java.lang.String mimeType); 646 647 /** 648 * Returns a range of all the document library file versions where mimeType = ?. 649 * 650 * <p> 651 * 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 DLFileVersionModelImpl}. 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. 652 * </p> 653 * 654 * @param mimeType the mime type 655 * @param start the lower bound of the range of document library file versions 656 * @param end the upper bound of the range of document library file versions (not inclusive) 657 * @return the range of matching document library file versions 658 */ 659 public java.util.List<DLFileVersion> findByMimeType( 660 java.lang.String mimeType, int start, int end); 661 662 /** 663 * Returns an ordered range of all the document library file versions where mimeType = ?. 664 * 665 * <p> 666 * 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 DLFileVersionModelImpl}. 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. 667 * </p> 668 * 669 * @param mimeType the mime type 670 * @param start the lower bound of the range of document library file versions 671 * @param end the upper bound of the range of document library file versions (not inclusive) 672 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 673 * @return the ordered range of matching document library file versions 674 */ 675 public java.util.List<DLFileVersion> findByMimeType( 676 java.lang.String mimeType, int start, int end, 677 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator); 678 679 /** 680 * Returns an ordered range of all the document library file versions where mimeType = ?. 681 * 682 * <p> 683 * 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 DLFileVersionModelImpl}. 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. 684 * </p> 685 * 686 * @param mimeType the mime type 687 * @param start the lower bound of the range of document library file versions 688 * @param end the upper bound of the range of document library file versions (not inclusive) 689 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 690 * @param retrieveFromCache whether to retrieve from the finder cache 691 * @return the ordered range of matching document library file versions 692 */ 693 public java.util.List<DLFileVersion> findByMimeType( 694 java.lang.String mimeType, int start, int end, 695 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator, 696 boolean retrieveFromCache); 697 698 /** 699 * Returns the first document library file version in the ordered set where mimeType = ?. 700 * 701 * @param mimeType the mime type 702 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 703 * @return the first matching document library file version 704 * @throws NoSuchFileVersionException if a matching document library file version could not be found 705 */ 706 public DLFileVersion findByMimeType_First(java.lang.String mimeType, 707 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator) 708 throws NoSuchFileVersionException; 709 710 /** 711 * Returns the first document library file version in the ordered set where mimeType = ?. 712 * 713 * @param mimeType the mime type 714 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 715 * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found 716 */ 717 public DLFileVersion fetchByMimeType_First(java.lang.String mimeType, 718 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator); 719 720 /** 721 * Returns the last document library file version in the ordered set where mimeType = ?. 722 * 723 * @param mimeType the mime type 724 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 725 * @return the last matching document library file version 726 * @throws NoSuchFileVersionException if a matching document library file version could not be found 727 */ 728 public DLFileVersion findByMimeType_Last(java.lang.String mimeType, 729 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator) 730 throws NoSuchFileVersionException; 731 732 /** 733 * Returns the last document library file version in the ordered set where mimeType = ?. 734 * 735 * @param mimeType the mime type 736 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 737 * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found 738 */ 739 public DLFileVersion fetchByMimeType_Last(java.lang.String mimeType, 740 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator); 741 742 /** 743 * Returns the document library file versions before and after the current document library file version in the ordered set where mimeType = ?. 744 * 745 * @param fileVersionId the primary key of the current document library file version 746 * @param mimeType the mime type 747 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 748 * @return the previous, current, and next document library file version 749 * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found 750 */ 751 public DLFileVersion[] findByMimeType_PrevAndNext(long fileVersionId, 752 java.lang.String mimeType, 753 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator) 754 throws NoSuchFileVersionException; 755 756 /** 757 * Removes all the document library file versions where mimeType = ? from the database. 758 * 759 * @param mimeType the mime type 760 */ 761 public void removeByMimeType(java.lang.String mimeType); 762 763 /** 764 * Returns the number of document library file versions where mimeType = ?. 765 * 766 * @param mimeType the mime type 767 * @return the number of matching document library file versions 768 */ 769 public int countByMimeType(java.lang.String mimeType); 770 771 /** 772 * Returns all the document library file versions where companyId = ? and status ≠ ?. 773 * 774 * @param companyId the company ID 775 * @param status the status 776 * @return the matching document library file versions 777 */ 778 public java.util.List<DLFileVersion> findByC_NotS(long companyId, int status); 779 780 /** 781 * Returns a range of all the document library file versions where companyId = ? and status ≠ ?. 782 * 783 * <p> 784 * 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 DLFileVersionModelImpl}. 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. 785 * </p> 786 * 787 * @param companyId the company ID 788 * @param status the status 789 * @param start the lower bound of the range of document library file versions 790 * @param end the upper bound of the range of document library file versions (not inclusive) 791 * @return the range of matching document library file versions 792 */ 793 public java.util.List<DLFileVersion> findByC_NotS(long companyId, 794 int status, int start, int end); 795 796 /** 797 * Returns an ordered range of all the document library file versions where companyId = ? and status ≠ ?. 798 * 799 * <p> 800 * 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 DLFileVersionModelImpl}. 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. 801 * </p> 802 * 803 * @param companyId the company ID 804 * @param status the status 805 * @param start the lower bound of the range of document library file versions 806 * @param end the upper bound of the range of document library file versions (not inclusive) 807 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 808 * @return the ordered range of matching document library file versions 809 */ 810 public java.util.List<DLFileVersion> findByC_NotS(long companyId, 811 int status, int start, int end, 812 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator); 813 814 /** 815 * Returns an ordered range of all the document library file versions where companyId = ? and status ≠ ?. 816 * 817 * <p> 818 * 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 DLFileVersionModelImpl}. 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. 819 * </p> 820 * 821 * @param companyId the company ID 822 * @param status the status 823 * @param start the lower bound of the range of document library file versions 824 * @param end the upper bound of the range of document library file versions (not inclusive) 825 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 826 * @param retrieveFromCache whether to retrieve from the finder cache 827 * @return the ordered range of matching document library file versions 828 */ 829 public java.util.List<DLFileVersion> findByC_NotS(long companyId, 830 int status, int start, int end, 831 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator, 832 boolean retrieveFromCache); 833 834 /** 835 * Returns the first document library file version in the ordered set where companyId = ? and status ≠ ?. 836 * 837 * @param companyId the company ID 838 * @param status the status 839 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 840 * @return the first matching document library file version 841 * @throws NoSuchFileVersionException if a matching document library file version could not be found 842 */ 843 public DLFileVersion findByC_NotS_First(long companyId, int status, 844 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator) 845 throws NoSuchFileVersionException; 846 847 /** 848 * Returns the first document library file version in the ordered set where companyId = ? and status ≠ ?. 849 * 850 * @param companyId the company ID 851 * @param status the status 852 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 853 * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found 854 */ 855 public DLFileVersion fetchByC_NotS_First(long companyId, int status, 856 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator); 857 858 /** 859 * Returns the last document library file version in the ordered set where companyId = ? and status ≠ ?. 860 * 861 * @param companyId the company ID 862 * @param status the status 863 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 864 * @return the last matching document library file version 865 * @throws NoSuchFileVersionException if a matching document library file version could not be found 866 */ 867 public DLFileVersion findByC_NotS_Last(long companyId, int status, 868 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator) 869 throws NoSuchFileVersionException; 870 871 /** 872 * Returns the last document library file version in the ordered set where companyId = ? and status ≠ ?. 873 * 874 * @param companyId the company ID 875 * @param status the status 876 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 877 * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found 878 */ 879 public DLFileVersion fetchByC_NotS_Last(long companyId, int status, 880 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator); 881 882 /** 883 * Returns the document library file versions before and after the current document library file version in the ordered set where companyId = ? and status ≠ ?. 884 * 885 * @param fileVersionId the primary key of the current document library file version 886 * @param companyId the company ID 887 * @param status the status 888 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 889 * @return the previous, current, and next document library file version 890 * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found 891 */ 892 public DLFileVersion[] findByC_NotS_PrevAndNext(long fileVersionId, 893 long companyId, int status, 894 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator) 895 throws NoSuchFileVersionException; 896 897 /** 898 * Removes all the document library file versions where companyId = ? and status ≠ ? from the database. 899 * 900 * @param companyId the company ID 901 * @param status the status 902 */ 903 public void removeByC_NotS(long companyId, int status); 904 905 /** 906 * Returns the number of document library file versions where companyId = ? and status ≠ ?. 907 * 908 * @param companyId the company ID 909 * @param status the status 910 * @return the number of matching document library file versions 911 */ 912 public int countByC_NotS(long companyId, int status); 913 914 /** 915 * Returns the document library file version where fileEntryId = ? and version = ? or throws a {@link NoSuchFileVersionException} if it could not be found. 916 * 917 * @param fileEntryId the file entry ID 918 * @param version the version 919 * @return the matching document library file version 920 * @throws NoSuchFileVersionException if a matching document library file version could not be found 921 */ 922 public DLFileVersion findByF_V(long fileEntryId, java.lang.String version) 923 throws NoSuchFileVersionException; 924 925 /** 926 * Returns the document library file version where fileEntryId = ? and version = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 927 * 928 * @param fileEntryId the file entry ID 929 * @param version the version 930 * @return the matching document library file version, or <code>null</code> if a matching document library file version could not be found 931 */ 932 public DLFileVersion fetchByF_V(long fileEntryId, java.lang.String version); 933 934 /** 935 * Returns the document library file version where fileEntryId = ? and version = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 936 * 937 * @param fileEntryId the file entry ID 938 * @param version the version 939 * @param retrieveFromCache whether to retrieve from the finder cache 940 * @return the matching document library file version, or <code>null</code> if a matching document library file version could not be found 941 */ 942 public DLFileVersion fetchByF_V(long fileEntryId, java.lang.String version, 943 boolean retrieveFromCache); 944 945 /** 946 * Removes the document library file version where fileEntryId = ? and version = ? from the database. 947 * 948 * @param fileEntryId the file entry ID 949 * @param version the version 950 * @return the document library file version that was removed 951 */ 952 public DLFileVersion removeByF_V(long fileEntryId, java.lang.String version) 953 throws NoSuchFileVersionException; 954 955 /** 956 * Returns the number of document library file versions where fileEntryId = ? and version = ?. 957 * 958 * @param fileEntryId the file entry ID 959 * @param version the version 960 * @return the number of matching document library file versions 961 */ 962 public int countByF_V(long fileEntryId, java.lang.String version); 963 964 /** 965 * Returns all the document library file versions where fileEntryId = ? and status = ?. 966 * 967 * @param fileEntryId the file entry ID 968 * @param status the status 969 * @return the matching document library file versions 970 */ 971 public java.util.List<DLFileVersion> findByF_S(long fileEntryId, int status); 972 973 /** 974 * Returns a range of all the document library file versions where fileEntryId = ? and status = ?. 975 * 976 * <p> 977 * 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 DLFileVersionModelImpl}. 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. 978 * </p> 979 * 980 * @param fileEntryId the file entry ID 981 * @param status the status 982 * @param start the lower bound of the range of document library file versions 983 * @param end the upper bound of the range of document library file versions (not inclusive) 984 * @return the range of matching document library file versions 985 */ 986 public java.util.List<DLFileVersion> findByF_S(long fileEntryId, 987 int status, int start, int end); 988 989 /** 990 * Returns an ordered range of all the document library file versions where fileEntryId = ? and status = ?. 991 * 992 * <p> 993 * 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 DLFileVersionModelImpl}. 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. 994 * </p> 995 * 996 * @param fileEntryId the file entry ID 997 * @param status the status 998 * @param start the lower bound of the range of document library file versions 999 * @param end the upper bound of the range of document library file versions (not inclusive) 1000 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1001 * @return the ordered range of matching document library file versions 1002 */ 1003 public java.util.List<DLFileVersion> findByF_S(long fileEntryId, 1004 int status, int start, int end, 1005 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator); 1006 1007 /** 1008 * Returns an ordered range of all the document library file versions where fileEntryId = ? and status = ?. 1009 * 1010 * <p> 1011 * 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 DLFileVersionModelImpl}. 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. 1012 * </p> 1013 * 1014 * @param fileEntryId the file entry ID 1015 * @param status the status 1016 * @param start the lower bound of the range of document library file versions 1017 * @param end the upper bound of the range of document library file versions (not inclusive) 1018 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1019 * @param retrieveFromCache whether to retrieve from the finder cache 1020 * @return the ordered range of matching document library file versions 1021 */ 1022 public java.util.List<DLFileVersion> findByF_S(long fileEntryId, 1023 int status, int start, int end, 1024 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator, 1025 boolean retrieveFromCache); 1026 1027 /** 1028 * Returns the first document library file version in the ordered set where fileEntryId = ? and status = ?. 1029 * 1030 * @param fileEntryId the file entry ID 1031 * @param status the status 1032 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1033 * @return the first matching document library file version 1034 * @throws NoSuchFileVersionException if a matching document library file version could not be found 1035 */ 1036 public DLFileVersion findByF_S_First(long fileEntryId, int status, 1037 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator) 1038 throws NoSuchFileVersionException; 1039 1040 /** 1041 * Returns the first document library file version in the ordered set where fileEntryId = ? and status = ?. 1042 * 1043 * @param fileEntryId the file entry ID 1044 * @param status the status 1045 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1046 * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found 1047 */ 1048 public DLFileVersion fetchByF_S_First(long fileEntryId, int status, 1049 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator); 1050 1051 /** 1052 * Returns the last document library file version in the ordered set where fileEntryId = ? and status = ?. 1053 * 1054 * @param fileEntryId the file entry ID 1055 * @param status the status 1056 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1057 * @return the last matching document library file version 1058 * @throws NoSuchFileVersionException if a matching document library file version could not be found 1059 */ 1060 public DLFileVersion findByF_S_Last(long fileEntryId, int status, 1061 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator) 1062 throws NoSuchFileVersionException; 1063 1064 /** 1065 * Returns the last document library file version in the ordered set where fileEntryId = ? and status = ?. 1066 * 1067 * @param fileEntryId the file entry ID 1068 * @param status the status 1069 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1070 * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found 1071 */ 1072 public DLFileVersion fetchByF_S_Last(long fileEntryId, int status, 1073 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator); 1074 1075 /** 1076 * Returns the document library file versions before and after the current document library file version in the ordered set where fileEntryId = ? and status = ?. 1077 * 1078 * @param fileVersionId the primary key of the current document library file version 1079 * @param fileEntryId the file entry ID 1080 * @param status the status 1081 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1082 * @return the previous, current, and next document library file version 1083 * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found 1084 */ 1085 public DLFileVersion[] findByF_S_PrevAndNext(long fileVersionId, 1086 long fileEntryId, int status, 1087 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator) 1088 throws NoSuchFileVersionException; 1089 1090 /** 1091 * Removes all the document library file versions where fileEntryId = ? and status = ? from the database. 1092 * 1093 * @param fileEntryId the file entry ID 1094 * @param status the status 1095 */ 1096 public void removeByF_S(long fileEntryId, int status); 1097 1098 /** 1099 * Returns the number of document library file versions where fileEntryId = ? and status = ?. 1100 * 1101 * @param fileEntryId the file entry ID 1102 * @param status the status 1103 * @return the number of matching document library file versions 1104 */ 1105 public int countByF_S(long fileEntryId, int status); 1106 1107 /** 1108 * Returns all the document library file versions where groupId = ? and folderId = ? and status = ?. 1109 * 1110 * @param groupId the group ID 1111 * @param folderId the folder ID 1112 * @param status the status 1113 * @return the matching document library file versions 1114 */ 1115 public java.util.List<DLFileVersion> findByG_F_S(long groupId, 1116 long folderId, int status); 1117 1118 /** 1119 * Returns a range of all the document library file versions where groupId = ? and folderId = ? and status = ?. 1120 * 1121 * <p> 1122 * 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 DLFileVersionModelImpl}. 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. 1123 * </p> 1124 * 1125 * @param groupId the group ID 1126 * @param folderId the folder ID 1127 * @param status the status 1128 * @param start the lower bound of the range of document library file versions 1129 * @param end the upper bound of the range of document library file versions (not inclusive) 1130 * @return the range of matching document library file versions 1131 */ 1132 public java.util.List<DLFileVersion> findByG_F_S(long groupId, 1133 long folderId, int status, int start, int end); 1134 1135 /** 1136 * Returns an ordered range of all the document library file versions where groupId = ? and folderId = ? and status = ?. 1137 * 1138 * <p> 1139 * 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 DLFileVersionModelImpl}. 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. 1140 * </p> 1141 * 1142 * @param groupId the group ID 1143 * @param folderId the folder ID 1144 * @param status the status 1145 * @param start the lower bound of the range of document library file versions 1146 * @param end the upper bound of the range of document library file versions (not inclusive) 1147 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1148 * @return the ordered range of matching document library file versions 1149 */ 1150 public java.util.List<DLFileVersion> findByG_F_S(long groupId, 1151 long folderId, int status, int start, int end, 1152 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator); 1153 1154 /** 1155 * Returns an ordered range of all the document library file versions where groupId = ? and folderId = ? and status = ?. 1156 * 1157 * <p> 1158 * 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 DLFileVersionModelImpl}. 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. 1159 * </p> 1160 * 1161 * @param groupId the group ID 1162 * @param folderId the folder ID 1163 * @param status the status 1164 * @param start the lower bound of the range of document library file versions 1165 * @param end the upper bound of the range of document library file versions (not inclusive) 1166 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1167 * @param retrieveFromCache whether to retrieve from the finder cache 1168 * @return the ordered range of matching document library file versions 1169 */ 1170 public java.util.List<DLFileVersion> findByG_F_S(long groupId, 1171 long folderId, int status, int start, int end, 1172 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator, 1173 boolean retrieveFromCache); 1174 1175 /** 1176 * Returns the first document library file version in the ordered set where groupId = ? and folderId = ? and status = ?. 1177 * 1178 * @param groupId the group ID 1179 * @param folderId the folder ID 1180 * @param status the status 1181 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1182 * @return the first matching document library file version 1183 * @throws NoSuchFileVersionException if a matching document library file version could not be found 1184 */ 1185 public DLFileVersion findByG_F_S_First(long groupId, long folderId, 1186 int status, 1187 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator) 1188 throws NoSuchFileVersionException; 1189 1190 /** 1191 * Returns the first document library file version in the ordered set where groupId = ? and folderId = ? and status = ?. 1192 * 1193 * @param groupId the group ID 1194 * @param folderId the folder ID 1195 * @param status the status 1196 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1197 * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found 1198 */ 1199 public DLFileVersion fetchByG_F_S_First(long groupId, long folderId, 1200 int status, 1201 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator); 1202 1203 /** 1204 * Returns the last document library file version in the ordered set where groupId = ? and folderId = ? and status = ?. 1205 * 1206 * @param groupId the group ID 1207 * @param folderId the folder ID 1208 * @param status the status 1209 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1210 * @return the last matching document library file version 1211 * @throws NoSuchFileVersionException if a matching document library file version could not be found 1212 */ 1213 public DLFileVersion findByG_F_S_Last(long groupId, long folderId, 1214 int status, 1215 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator) 1216 throws NoSuchFileVersionException; 1217 1218 /** 1219 * Returns the last document library file version in the ordered set where groupId = ? and folderId = ? and status = ?. 1220 * 1221 * @param groupId the group ID 1222 * @param folderId the folder ID 1223 * @param status the status 1224 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1225 * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found 1226 */ 1227 public DLFileVersion fetchByG_F_S_Last(long groupId, long folderId, 1228 int status, 1229 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator); 1230 1231 /** 1232 * Returns the document library file versions before and after the current document library file version in the ordered set where groupId = ? and folderId = ? and status = ?. 1233 * 1234 * @param fileVersionId the primary key of the current document library file version 1235 * @param groupId the group ID 1236 * @param folderId the folder ID 1237 * @param status the status 1238 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1239 * @return the previous, current, and next document library file version 1240 * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found 1241 */ 1242 public DLFileVersion[] findByG_F_S_PrevAndNext(long fileVersionId, 1243 long groupId, long folderId, int status, 1244 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator) 1245 throws NoSuchFileVersionException; 1246 1247 /** 1248 * Removes all the document library file versions where groupId = ? and folderId = ? and status = ? from the database. 1249 * 1250 * @param groupId the group ID 1251 * @param folderId the folder ID 1252 * @param status the status 1253 */ 1254 public void removeByG_F_S(long groupId, long folderId, int status); 1255 1256 /** 1257 * Returns the number of document library file versions where groupId = ? and folderId = ? and status = ?. 1258 * 1259 * @param groupId the group ID 1260 * @param folderId the folder ID 1261 * @param status the status 1262 * @return the number of matching document library file versions 1263 */ 1264 public int countByG_F_S(long groupId, long folderId, int status); 1265 1266 /** 1267 * Returns all the document library file versions where groupId = ? and folderId = ? and title = ? and version = ?. 1268 * 1269 * @param groupId the group ID 1270 * @param folderId the folder ID 1271 * @param title the title 1272 * @param version the version 1273 * @return the matching document library file versions 1274 */ 1275 public java.util.List<DLFileVersion> findByG_F_T_V(long groupId, 1276 long folderId, java.lang.String title, java.lang.String version); 1277 1278 /** 1279 * Returns a range of all the document library file versions where groupId = ? and folderId = ? and title = ? and version = ?. 1280 * 1281 * <p> 1282 * 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 DLFileVersionModelImpl}. 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. 1283 * </p> 1284 * 1285 * @param groupId the group ID 1286 * @param folderId the folder ID 1287 * @param title the title 1288 * @param version the version 1289 * @param start the lower bound of the range of document library file versions 1290 * @param end the upper bound of the range of document library file versions (not inclusive) 1291 * @return the range of matching document library file versions 1292 */ 1293 public java.util.List<DLFileVersion> findByG_F_T_V(long groupId, 1294 long folderId, java.lang.String title, java.lang.String version, 1295 int start, int end); 1296 1297 /** 1298 * Returns an ordered range of all the document library file versions where groupId = ? and folderId = ? and title = ? and version = ?. 1299 * 1300 * <p> 1301 * 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 DLFileVersionModelImpl}. 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. 1302 * </p> 1303 * 1304 * @param groupId the group ID 1305 * @param folderId the folder ID 1306 * @param title the title 1307 * @param version the version 1308 * @param start the lower bound of the range of document library file versions 1309 * @param end the upper bound of the range of document library file versions (not inclusive) 1310 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1311 * @return the ordered range of matching document library file versions 1312 */ 1313 public java.util.List<DLFileVersion> findByG_F_T_V(long groupId, 1314 long folderId, java.lang.String title, java.lang.String version, 1315 int start, int end, 1316 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator); 1317 1318 /** 1319 * Returns an ordered range of all the document library file versions where groupId = ? and folderId = ? and title = ? and version = ?. 1320 * 1321 * <p> 1322 * 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 DLFileVersionModelImpl}. 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. 1323 * </p> 1324 * 1325 * @param groupId the group ID 1326 * @param folderId the folder ID 1327 * @param title the title 1328 * @param version the version 1329 * @param start the lower bound of the range of document library file versions 1330 * @param end the upper bound of the range of document library file versions (not inclusive) 1331 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1332 * @param retrieveFromCache whether to retrieve from the finder cache 1333 * @return the ordered range of matching document library file versions 1334 */ 1335 public java.util.List<DLFileVersion> findByG_F_T_V(long groupId, 1336 long folderId, java.lang.String title, java.lang.String version, 1337 int start, int end, 1338 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator, 1339 boolean retrieveFromCache); 1340 1341 /** 1342 * Returns the first document library file version in the ordered set where groupId = ? and folderId = ? and title = ? and version = ?. 1343 * 1344 * @param groupId the group ID 1345 * @param folderId the folder ID 1346 * @param title the title 1347 * @param version the version 1348 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1349 * @return the first matching document library file version 1350 * @throws NoSuchFileVersionException if a matching document library file version could not be found 1351 */ 1352 public DLFileVersion findByG_F_T_V_First(long groupId, long folderId, 1353 java.lang.String title, java.lang.String version, 1354 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator) 1355 throws NoSuchFileVersionException; 1356 1357 /** 1358 * Returns the first document library file version in the ordered set where groupId = ? and folderId = ? and title = ? and version = ?. 1359 * 1360 * @param groupId the group ID 1361 * @param folderId the folder ID 1362 * @param title the title 1363 * @param version the version 1364 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1365 * @return the first matching document library file version, or <code>null</code> if a matching document library file version could not be found 1366 */ 1367 public DLFileVersion fetchByG_F_T_V_First(long groupId, long folderId, 1368 java.lang.String title, java.lang.String version, 1369 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator); 1370 1371 /** 1372 * Returns the last document library file version in the ordered set where groupId = ? and folderId = ? and title = ? and version = ?. 1373 * 1374 * @param groupId the group ID 1375 * @param folderId the folder ID 1376 * @param title the title 1377 * @param version the version 1378 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1379 * @return the last matching document library file version 1380 * @throws NoSuchFileVersionException if a matching document library file version could not be found 1381 */ 1382 public DLFileVersion findByG_F_T_V_Last(long groupId, long folderId, 1383 java.lang.String title, java.lang.String version, 1384 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator) 1385 throws NoSuchFileVersionException; 1386 1387 /** 1388 * Returns the last document library file version in the ordered set where groupId = ? and folderId = ? and title = ? and version = ?. 1389 * 1390 * @param groupId the group ID 1391 * @param folderId the folder ID 1392 * @param title the title 1393 * @param version the version 1394 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1395 * @return the last matching document library file version, or <code>null</code> if a matching document library file version could not be found 1396 */ 1397 public DLFileVersion fetchByG_F_T_V_Last(long groupId, long folderId, 1398 java.lang.String title, java.lang.String version, 1399 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator); 1400 1401 /** 1402 * Returns the document library file versions before and after the current document library file version in the ordered set where groupId = ? and folderId = ? and title = ? and version = ?. 1403 * 1404 * @param fileVersionId the primary key of the current document library file version 1405 * @param groupId the group ID 1406 * @param folderId the folder ID 1407 * @param title the title 1408 * @param version the version 1409 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1410 * @return the previous, current, and next document library file version 1411 * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found 1412 */ 1413 public DLFileVersion[] findByG_F_T_V_PrevAndNext(long fileVersionId, 1414 long groupId, long folderId, java.lang.String title, 1415 java.lang.String version, 1416 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator) 1417 throws NoSuchFileVersionException; 1418 1419 /** 1420 * Removes all the document library file versions where groupId = ? and folderId = ? and title = ? and version = ? from the database. 1421 * 1422 * @param groupId the group ID 1423 * @param folderId the folder ID 1424 * @param title the title 1425 * @param version the version 1426 */ 1427 public void removeByG_F_T_V(long groupId, long folderId, 1428 java.lang.String title, java.lang.String version); 1429 1430 /** 1431 * Returns the number of document library file versions where groupId = ? and folderId = ? and title = ? and version = ?. 1432 * 1433 * @param groupId the group ID 1434 * @param folderId the folder ID 1435 * @param title the title 1436 * @param version the version 1437 * @return the number of matching document library file versions 1438 */ 1439 public int countByG_F_T_V(long groupId, long folderId, 1440 java.lang.String title, java.lang.String version); 1441 1442 /** 1443 * Caches the document library file version in the entity cache if it is enabled. 1444 * 1445 * @param dlFileVersion the document library file version 1446 */ 1447 public void cacheResult(DLFileVersion dlFileVersion); 1448 1449 /** 1450 * Caches the document library file versions in the entity cache if it is enabled. 1451 * 1452 * @param dlFileVersions the document library file versions 1453 */ 1454 public void cacheResult(java.util.List<DLFileVersion> dlFileVersions); 1455 1456 /** 1457 * Creates a new document library file version with the primary key. Does not add the document library file version to the database. 1458 * 1459 * @param fileVersionId the primary key for the new document library file version 1460 * @return the new document library file version 1461 */ 1462 public DLFileVersion create(long fileVersionId); 1463 1464 /** 1465 * Removes the document library file version with the primary key from the database. Also notifies the appropriate model listeners. 1466 * 1467 * @param fileVersionId the primary key of the document library file version 1468 * @return the document library file version that was removed 1469 * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found 1470 */ 1471 public DLFileVersion remove(long fileVersionId) 1472 throws NoSuchFileVersionException; 1473 1474 public DLFileVersion updateImpl(DLFileVersion dlFileVersion); 1475 1476 /** 1477 * Returns the document library file version with the primary key or throws a {@link NoSuchFileVersionException} if it could not be found. 1478 * 1479 * @param fileVersionId the primary key of the document library file version 1480 * @return the document library file version 1481 * @throws NoSuchFileVersionException if a document library file version with the primary key could not be found 1482 */ 1483 public DLFileVersion findByPrimaryKey(long fileVersionId) 1484 throws NoSuchFileVersionException; 1485 1486 /** 1487 * Returns the document library file version with the primary key or returns <code>null</code> if it could not be found. 1488 * 1489 * @param fileVersionId the primary key of the document library file version 1490 * @return the document library file version, or <code>null</code> if a document library file version with the primary key could not be found 1491 */ 1492 public DLFileVersion fetchByPrimaryKey(long fileVersionId); 1493 1494 @Override 1495 public java.util.Map<java.io.Serializable, DLFileVersion> fetchByPrimaryKeys( 1496 java.util.Set<java.io.Serializable> primaryKeys); 1497 1498 /** 1499 * Returns all the document library file versions. 1500 * 1501 * @return the document library file versions 1502 */ 1503 public java.util.List<DLFileVersion> findAll(); 1504 1505 /** 1506 * Returns a range of all the document library file versions. 1507 * 1508 * <p> 1509 * 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 DLFileVersionModelImpl}. 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. 1510 * </p> 1511 * 1512 * @param start the lower bound of the range of document library file versions 1513 * @param end the upper bound of the range of document library file versions (not inclusive) 1514 * @return the range of document library file versions 1515 */ 1516 public java.util.List<DLFileVersion> findAll(int start, int end); 1517 1518 /** 1519 * Returns an ordered range of all the document library file versions. 1520 * 1521 * <p> 1522 * 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 DLFileVersionModelImpl}. 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. 1523 * </p> 1524 * 1525 * @param start the lower bound of the range of document library file versions 1526 * @param end the upper bound of the range of document library file versions (not inclusive) 1527 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1528 * @return the ordered range of document library file versions 1529 */ 1530 public java.util.List<DLFileVersion> findAll(int start, int end, 1531 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator); 1532 1533 /** 1534 * Returns an ordered range of all the document library file versions. 1535 * 1536 * <p> 1537 * 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 DLFileVersionModelImpl}. 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. 1538 * </p> 1539 * 1540 * @param start the lower bound of the range of document library file versions 1541 * @param end the upper bound of the range of document library file versions (not inclusive) 1542 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1543 * @param retrieveFromCache whether to retrieve from the finder cache 1544 * @return the ordered range of document library file versions 1545 */ 1546 public java.util.List<DLFileVersion> findAll(int start, int end, 1547 com.liferay.portal.kernel.util.OrderByComparator<DLFileVersion> orderByComparator, 1548 boolean retrieveFromCache); 1549 1550 /** 1551 * Removes all the document library file versions from the database. 1552 */ 1553 public void removeAll(); 1554 1555 /** 1556 * Returns the number of document library file versions. 1557 * 1558 * @return the number of document library file versions 1559 */ 1560 public int countAll(); 1561 1562 @Override 1563 public java.util.Set<java.lang.String> getBadColumnNames(); 1564 }