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.portlet.softwarecatalog.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.service.persistence.BasePersistence; 020 021 import com.liferay.portlet.softwarecatalog.model.SCProductVersion; 022 023 /** 024 * The persistence interface for the s c product version service. 025 * 026 * <p> 027 * Caching information and settings can be found in <code>portal.properties</code> 028 * </p> 029 * 030 * @author Brian Wing Shun Chan 031 * @see com.liferay.portlet.softwarecatalog.service.persistence.impl.SCProductVersionPersistenceImpl 032 * @see SCProductVersionUtil 033 * @generated 034 */ 035 @ProviderType 036 public interface SCProductVersionPersistence extends BasePersistence<SCProductVersion> { 037 /* 038 * NOTE FOR DEVELOPERS: 039 * 040 * Never modify or reference this interface directly. Always use {@link SCProductVersionUtil} to access the s c product version persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 041 */ 042 043 /** 044 * Returns all the s c product versions where productEntryId = ?. 045 * 046 * @param productEntryId the product entry ID 047 * @return the matching s c product versions 048 */ 049 public java.util.List<SCProductVersion> findByProductEntryId( 050 long productEntryId); 051 052 /** 053 * Returns a range of all the s c product versions where productEntryId = ?. 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 SCProductVersionModelImpl}. 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 productEntryId the product entry ID 060 * @param start the lower bound of the range of s c product versions 061 * @param end the upper bound of the range of s c product versions (not inclusive) 062 * @return the range of matching s c product versions 063 */ 064 public java.util.List<SCProductVersion> findByProductEntryId( 065 long productEntryId, int start, int end); 066 067 /** 068 * Returns an ordered range of all the s c product versions where productEntryId = ?. 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 SCProductVersionModelImpl}. 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 productEntryId the product entry ID 075 * @param start the lower bound of the range of s c product versions 076 * @param end the upper bound of the range of s c product versions (not inclusive) 077 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 078 * @return the ordered range of matching s c product versions 079 */ 080 public java.util.List<SCProductVersion> findByProductEntryId( 081 long productEntryId, int start, int end, 082 com.liferay.portal.kernel.util.OrderByComparator<SCProductVersion> orderByComparator); 083 084 /** 085 * Returns the first s c product version in the ordered set where productEntryId = ?. 086 * 087 * @param productEntryId the product entry ID 088 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 089 * @return the first matching s c product version 090 * @throws NoSuchProductVersionException if a matching s c product version could not be found 091 */ 092 public SCProductVersion findByProductEntryId_First(long productEntryId, 093 com.liferay.portal.kernel.util.OrderByComparator<SCProductVersion> orderByComparator) 094 throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException; 095 096 /** 097 * Returns the first s c product version in the ordered set where productEntryId = ?. 098 * 099 * @param productEntryId the product entry ID 100 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 101 * @return the first matching s c product version, or <code>null</code> if a matching s c product version could not be found 102 */ 103 public SCProductVersion fetchByProductEntryId_First(long productEntryId, 104 com.liferay.portal.kernel.util.OrderByComparator<SCProductVersion> orderByComparator); 105 106 /** 107 * Returns the last s c product version in the ordered set where productEntryId = ?. 108 * 109 * @param productEntryId the product entry ID 110 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 111 * @return the last matching s c product version 112 * @throws NoSuchProductVersionException if a matching s c product version could not be found 113 */ 114 public SCProductVersion findByProductEntryId_Last(long productEntryId, 115 com.liferay.portal.kernel.util.OrderByComparator<SCProductVersion> orderByComparator) 116 throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException; 117 118 /** 119 * Returns the last s c product version in the ordered set where productEntryId = ?. 120 * 121 * @param productEntryId the product entry ID 122 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 123 * @return the last matching s c product version, or <code>null</code> if a matching s c product version could not be found 124 */ 125 public SCProductVersion fetchByProductEntryId_Last(long productEntryId, 126 com.liferay.portal.kernel.util.OrderByComparator<SCProductVersion> orderByComparator); 127 128 /** 129 * Returns the s c product versions before and after the current s c product version in the ordered set where productEntryId = ?. 130 * 131 * @param productVersionId the primary key of the current s c product version 132 * @param productEntryId the product entry ID 133 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 134 * @return the previous, current, and next s c product version 135 * @throws NoSuchProductVersionException if a s c product version with the primary key could not be found 136 */ 137 public SCProductVersion[] findByProductEntryId_PrevAndNext( 138 long productVersionId, long productEntryId, 139 com.liferay.portal.kernel.util.OrderByComparator<SCProductVersion> orderByComparator) 140 throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException; 141 142 /** 143 * Removes all the s c product versions where productEntryId = ? from the database. 144 * 145 * @param productEntryId the product entry ID 146 */ 147 public void removeByProductEntryId(long productEntryId); 148 149 /** 150 * Returns the number of s c product versions where productEntryId = ?. 151 * 152 * @param productEntryId the product entry ID 153 * @return the number of matching s c product versions 154 */ 155 public int countByProductEntryId(long productEntryId); 156 157 /** 158 * Returns the s c product version where directDownloadURL = ? or throws a {@link NoSuchProductVersionException} if it could not be found. 159 * 160 * @param directDownloadURL the direct download u r l 161 * @return the matching s c product version 162 * @throws NoSuchProductVersionException if a matching s c product version could not be found 163 */ 164 public SCProductVersion findByDirectDownloadURL( 165 java.lang.String directDownloadURL) 166 throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException; 167 168 /** 169 * Returns the s c product version where directDownloadURL = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 170 * 171 * @param directDownloadURL the direct download u r l 172 * @return the matching s c product version, or <code>null</code> if a matching s c product version could not be found 173 */ 174 public SCProductVersion fetchByDirectDownloadURL( 175 java.lang.String directDownloadURL); 176 177 /** 178 * Returns the s c product version where directDownloadURL = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 179 * 180 * @param directDownloadURL the direct download u r l 181 * @param retrieveFromCache whether to use the finder cache 182 * @return the matching s c product version, or <code>null</code> if a matching s c product version could not be found 183 */ 184 public SCProductVersion fetchByDirectDownloadURL( 185 java.lang.String directDownloadURL, boolean retrieveFromCache); 186 187 /** 188 * Removes the s c product version where directDownloadURL = ? from the database. 189 * 190 * @param directDownloadURL the direct download u r l 191 * @return the s c product version that was removed 192 */ 193 public SCProductVersion removeByDirectDownloadURL( 194 java.lang.String directDownloadURL) 195 throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException; 196 197 /** 198 * Returns the number of s c product versions where directDownloadURL = ?. 199 * 200 * @param directDownloadURL the direct download u r l 201 * @return the number of matching s c product versions 202 */ 203 public int countByDirectDownloadURL(java.lang.String directDownloadURL); 204 205 /** 206 * Caches the s c product version in the entity cache if it is enabled. 207 * 208 * @param scProductVersion the s c product version 209 */ 210 public void cacheResult(SCProductVersion scProductVersion); 211 212 /** 213 * Caches the s c product versions in the entity cache if it is enabled. 214 * 215 * @param scProductVersions the s c product versions 216 */ 217 public void cacheResult(java.util.List<SCProductVersion> scProductVersions); 218 219 /** 220 * Creates a new s c product version with the primary key. Does not add the s c product version to the database. 221 * 222 * @param productVersionId the primary key for the new s c product version 223 * @return the new s c product version 224 */ 225 public SCProductVersion create(long productVersionId); 226 227 /** 228 * Removes the s c product version with the primary key from the database. Also notifies the appropriate model listeners. 229 * 230 * @param productVersionId the primary key of the s c product version 231 * @return the s c product version that was removed 232 * @throws NoSuchProductVersionException if a s c product version with the primary key could not be found 233 */ 234 public SCProductVersion remove(long productVersionId) 235 throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException; 236 237 public SCProductVersion updateImpl(SCProductVersion scProductVersion); 238 239 /** 240 * Returns the s c product version with the primary key or throws a {@link NoSuchProductVersionException} if it could not be found. 241 * 242 * @param productVersionId the primary key of the s c product version 243 * @return the s c product version 244 * @throws NoSuchProductVersionException if a s c product version with the primary key could not be found 245 */ 246 public SCProductVersion findByPrimaryKey(long productVersionId) 247 throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException; 248 249 /** 250 * Returns the s c product version with the primary key or returns <code>null</code> if it could not be found. 251 * 252 * @param productVersionId the primary key of the s c product version 253 * @return the s c product version, or <code>null</code> if a s c product version with the primary key could not be found 254 */ 255 public SCProductVersion fetchByPrimaryKey(long productVersionId); 256 257 @Override 258 public java.util.Map<java.io.Serializable, SCProductVersion> fetchByPrimaryKeys( 259 java.util.Set<java.io.Serializable> primaryKeys); 260 261 /** 262 * Returns all the s c product versions. 263 * 264 * @return the s c product versions 265 */ 266 public java.util.List<SCProductVersion> findAll(); 267 268 /** 269 * Returns a range of all the s c product versions. 270 * 271 * <p> 272 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SCProductVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 273 * </p> 274 * 275 * @param start the lower bound of the range of s c product versions 276 * @param end the upper bound of the range of s c product versions (not inclusive) 277 * @return the range of s c product versions 278 */ 279 public java.util.List<SCProductVersion> findAll(int start, int end); 280 281 /** 282 * Returns an ordered range of all the s c product versions. 283 * 284 * <p> 285 * 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 SCProductVersionModelImpl}. 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. 286 * </p> 287 * 288 * @param start the lower bound of the range of s c product versions 289 * @param end the upper bound of the range of s c product versions (not inclusive) 290 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 291 * @return the ordered range of s c product versions 292 */ 293 public java.util.List<SCProductVersion> findAll(int start, int end, 294 com.liferay.portal.kernel.util.OrderByComparator<SCProductVersion> orderByComparator); 295 296 /** 297 * Removes all the s c product versions from the database. 298 */ 299 public void removeAll(); 300 301 /** 302 * Returns the number of s c product versions. 303 * 304 * @return the number of s c product versions 305 */ 306 public int countAll(); 307 308 /** 309 * Returns the primaryKeys of s c framework versions associated with the s c product version. 310 * 311 * @param pk the primary key of the s c product version 312 * @return long[] of the primaryKeys of s c framework versions associated with the s c product version 313 */ 314 public long[] getSCFrameworkVersionPrimaryKeys(long pk); 315 316 /** 317 * Returns all the s c framework versions associated with the s c product version. 318 * 319 * @param pk the primary key of the s c product version 320 * @return the s c framework versions associated with the s c product version 321 */ 322 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getSCFrameworkVersions( 323 long pk); 324 325 /** 326 * Returns a range of all the s c framework versions associated with the s c product version. 327 * 328 * <p> 329 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SCProductVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 330 * </p> 331 * 332 * @param pk the primary key of the s c product version 333 * @param start the lower bound of the range of s c product versions 334 * @param end the upper bound of the range of s c product versions (not inclusive) 335 * @return the range of s c framework versions associated with the s c product version 336 */ 337 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getSCFrameworkVersions( 338 long pk, int start, int end); 339 340 /** 341 * Returns an ordered range of all the s c framework versions associated with the s c product version. 342 * 343 * <p> 344 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SCProductVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 345 * </p> 346 * 347 * @param pk the primary key of the s c product version 348 * @param start the lower bound of the range of s c product versions 349 * @param end the upper bound of the range of s c product versions (not inclusive) 350 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 351 * @return the ordered range of s c framework versions associated with the s c product version 352 */ 353 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getSCFrameworkVersions( 354 long pk, int start, int end, 355 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> orderByComparator); 356 357 /** 358 * Returns the number of s c framework versions associated with the s c product version. 359 * 360 * @param pk the primary key of the s c product version 361 * @return the number of s c framework versions associated with the s c product version 362 */ 363 public int getSCFrameworkVersionsSize(long pk); 364 365 /** 366 * Returns <code>true</code> if the s c framework version is associated with the s c product version. 367 * 368 * @param pk the primary key of the s c product version 369 * @param scFrameworkVersionPK the primary key of the s c framework version 370 * @return <code>true</code> if the s c framework version is associated with the s c product version; <code>false</code> otherwise 371 */ 372 public boolean containsSCFrameworkVersion(long pk, long scFrameworkVersionPK); 373 374 /** 375 * Returns <code>true</code> if the s c product version has any s c framework versions associated with it. 376 * 377 * @param pk the primary key of the s c product version to check for associations with s c framework versions 378 * @return <code>true</code> if the s c product version has any s c framework versions associated with it; <code>false</code> otherwise 379 */ 380 public boolean containsSCFrameworkVersions(long pk); 381 382 /** 383 * Adds an association between the s c product version and the s c framework version. Also notifies the appropriate model listeners and clears the mapping table finder cache. 384 * 385 * @param pk the primary key of the s c product version 386 * @param scFrameworkVersionPK the primary key of the s c framework version 387 */ 388 public void addSCFrameworkVersion(long pk, long scFrameworkVersionPK); 389 390 /** 391 * Adds an association between the s c product version and the s c framework version. Also notifies the appropriate model listeners and clears the mapping table finder cache. 392 * 393 * @param pk the primary key of the s c product version 394 * @param scFrameworkVersion the s c framework version 395 */ 396 public void addSCFrameworkVersion(long pk, 397 com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion); 398 399 /** 400 * Adds an association between the s c product version and the s c framework versions. Also notifies the appropriate model listeners and clears the mapping table finder cache. 401 * 402 * @param pk the primary key of the s c product version 403 * @param scFrameworkVersionPKs the primary keys of the s c framework versions 404 */ 405 public void addSCFrameworkVersions(long pk, long[] scFrameworkVersionPKs); 406 407 /** 408 * Adds an association between the s c product version and the s c framework versions. Also notifies the appropriate model listeners and clears the mapping table finder cache. 409 * 410 * @param pk the primary key of the s c product version 411 * @param scFrameworkVersions the s c framework versions 412 */ 413 public void addSCFrameworkVersions(long pk, 414 java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> scFrameworkVersions); 415 416 /** 417 * Clears all associations between the s c product version and its s c framework versions. Also notifies the appropriate model listeners and clears the mapping table finder cache. 418 * 419 * @param pk the primary key of the s c product version to clear the associated s c framework versions from 420 */ 421 public void clearSCFrameworkVersions(long pk); 422 423 /** 424 * Removes the association between the s c product version and the s c framework version. Also notifies the appropriate model listeners and clears the mapping table finder cache. 425 * 426 * @param pk the primary key of the s c product version 427 * @param scFrameworkVersionPK the primary key of the s c framework version 428 */ 429 public void removeSCFrameworkVersion(long pk, long scFrameworkVersionPK); 430 431 /** 432 * Removes the association between the s c product version and the s c framework version. Also notifies the appropriate model listeners and clears the mapping table finder cache. 433 * 434 * @param pk the primary key of the s c product version 435 * @param scFrameworkVersion the s c framework version 436 */ 437 public void removeSCFrameworkVersion(long pk, 438 com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion); 439 440 /** 441 * Removes the association between the s c product version and the s c framework versions. Also notifies the appropriate model listeners and clears the mapping table finder cache. 442 * 443 * @param pk the primary key of the s c product version 444 * @param scFrameworkVersionPKs the primary keys of the s c framework versions 445 */ 446 public void removeSCFrameworkVersions(long pk, long[] scFrameworkVersionPKs); 447 448 /** 449 * Removes the association between the s c product version and the s c framework versions. Also notifies the appropriate model listeners and clears the mapping table finder cache. 450 * 451 * @param pk the primary key of the s c product version 452 * @param scFrameworkVersions the s c framework versions 453 */ 454 public void removeSCFrameworkVersions(long pk, 455 java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> scFrameworkVersions); 456 457 /** 458 * Sets the s c framework versions associated with the s c product version, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 459 * 460 * @param pk the primary key of the s c product version 461 * @param scFrameworkVersionPKs the primary keys of the s c framework versions to be associated with the s c product version 462 */ 463 public void setSCFrameworkVersions(long pk, long[] scFrameworkVersionPKs); 464 465 /** 466 * Sets the s c framework versions associated with the s c product version, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 467 * 468 * @param pk the primary key of the s c product version 469 * @param scFrameworkVersions the s c framework versions to be associated with the s c product version 470 */ 471 public void setSCFrameworkVersions(long pk, 472 java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> scFrameworkVersions); 473 }