001 /** 002 * Copyright (c) 2000-present Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portal.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.model.Subscription; 020 021 /** 022 * The persistence interface for the subscription service. 023 * 024 * <p> 025 * Caching information and settings can be found in <code>portal.properties</code> 026 * </p> 027 * 028 * @author Brian Wing Shun Chan 029 * @see com.liferay.portal.service.persistence.impl.SubscriptionPersistenceImpl 030 * @see SubscriptionUtil 031 * @generated 032 */ 033 @ProviderType 034 public interface SubscriptionPersistence extends BasePersistence<Subscription> { 035 /* 036 * NOTE FOR DEVELOPERS: 037 * 038 * Never modify or reference this interface directly. Always use {@link SubscriptionUtil} to access the subscription persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 039 */ 040 041 /** 042 * Returns all the subscriptions where userId = ?. 043 * 044 * @param userId the user ID 045 * @return the matching subscriptions 046 */ 047 public java.util.List<Subscription> findByUserId(long userId); 048 049 /** 050 * Returns a range of all the subscriptions where userId = ?. 051 * 052 * <p> 053 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SubscriptionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 054 * </p> 055 * 056 * @param userId the user ID 057 * @param start the lower bound of the range of subscriptions 058 * @param end the upper bound of the range of subscriptions (not inclusive) 059 * @return the range of matching subscriptions 060 */ 061 public java.util.List<Subscription> findByUserId(long userId, int start, 062 int end); 063 064 /** 065 * Returns an ordered range of all the subscriptions where userId = ?. 066 * 067 * <p> 068 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SubscriptionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 069 * </p> 070 * 071 * @param userId the user ID 072 * @param start the lower bound of the range of subscriptions 073 * @param end the upper bound of the range of subscriptions (not inclusive) 074 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 075 * @return the ordered range of matching subscriptions 076 */ 077 public java.util.List<Subscription> findByUserId(long userId, int start, 078 int end, 079 com.liferay.portal.kernel.util.OrderByComparator<Subscription> orderByComparator); 080 081 /** 082 * Returns an ordered range of all the subscriptions where userId = ?. 083 * 084 * <p> 085 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SubscriptionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 086 * </p> 087 * 088 * @param userId the user ID 089 * @param start the lower bound of the range of subscriptions 090 * @param end the upper bound of the range of subscriptions (not inclusive) 091 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 092 * @param retrieveFromCache whether to retrieve from the finder cache 093 * @return the ordered range of matching subscriptions 094 */ 095 public java.util.List<Subscription> findByUserId(long userId, int start, 096 int end, 097 com.liferay.portal.kernel.util.OrderByComparator<Subscription> orderByComparator, 098 boolean retrieveFromCache); 099 100 /** 101 * Returns the first subscription in the ordered set where userId = ?. 102 * 103 * @param userId the user ID 104 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 105 * @return the first matching subscription 106 * @throws NoSuchSubscriptionException if a matching subscription could not be found 107 */ 108 public Subscription findByUserId_First(long userId, 109 com.liferay.portal.kernel.util.OrderByComparator<Subscription> orderByComparator) 110 throws com.liferay.portal.exception.NoSuchSubscriptionException; 111 112 /** 113 * Returns the first subscription in the ordered set where userId = ?. 114 * 115 * @param userId the user ID 116 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 117 * @return the first matching subscription, or <code>null</code> if a matching subscription could not be found 118 */ 119 public Subscription fetchByUserId_First(long userId, 120 com.liferay.portal.kernel.util.OrderByComparator<Subscription> orderByComparator); 121 122 /** 123 * Returns the last subscription in the ordered set where userId = ?. 124 * 125 * @param userId the user ID 126 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 127 * @return the last matching subscription 128 * @throws NoSuchSubscriptionException if a matching subscription could not be found 129 */ 130 public Subscription findByUserId_Last(long userId, 131 com.liferay.portal.kernel.util.OrderByComparator<Subscription> orderByComparator) 132 throws com.liferay.portal.exception.NoSuchSubscriptionException; 133 134 /** 135 * Returns the last subscription in the ordered set where userId = ?. 136 * 137 * @param userId the user ID 138 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 139 * @return the last matching subscription, or <code>null</code> if a matching subscription could not be found 140 */ 141 public Subscription fetchByUserId_Last(long userId, 142 com.liferay.portal.kernel.util.OrderByComparator<Subscription> orderByComparator); 143 144 /** 145 * Returns the subscriptions before and after the current subscription in the ordered set where userId = ?. 146 * 147 * @param subscriptionId the primary key of the current subscription 148 * @param userId the user ID 149 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 150 * @return the previous, current, and next subscription 151 * @throws NoSuchSubscriptionException if a subscription with the primary key could not be found 152 */ 153 public Subscription[] findByUserId_PrevAndNext(long subscriptionId, 154 long userId, 155 com.liferay.portal.kernel.util.OrderByComparator<Subscription> orderByComparator) 156 throws com.liferay.portal.exception.NoSuchSubscriptionException; 157 158 /** 159 * Removes all the subscriptions where userId = ? from the database. 160 * 161 * @param userId the user ID 162 */ 163 public void removeByUserId(long userId); 164 165 /** 166 * Returns the number of subscriptions where userId = ?. 167 * 168 * @param userId the user ID 169 * @return the number of matching subscriptions 170 */ 171 public int countByUserId(long userId); 172 173 /** 174 * Returns all the subscriptions where groupId = ? and userId = ?. 175 * 176 * @param groupId the group ID 177 * @param userId the user ID 178 * @return the matching subscriptions 179 */ 180 public java.util.List<Subscription> findByG_U(long groupId, long userId); 181 182 /** 183 * Returns a range of all the subscriptions where groupId = ? and userId = ?. 184 * 185 * <p> 186 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SubscriptionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 187 * </p> 188 * 189 * @param groupId the group ID 190 * @param userId the user ID 191 * @param start the lower bound of the range of subscriptions 192 * @param end the upper bound of the range of subscriptions (not inclusive) 193 * @return the range of matching subscriptions 194 */ 195 public java.util.List<Subscription> findByG_U(long groupId, long userId, 196 int start, int end); 197 198 /** 199 * Returns an ordered range of all the subscriptions where groupId = ? and userId = ?. 200 * 201 * <p> 202 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SubscriptionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 203 * </p> 204 * 205 * @param groupId the group ID 206 * @param userId the user ID 207 * @param start the lower bound of the range of subscriptions 208 * @param end the upper bound of the range of subscriptions (not inclusive) 209 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 210 * @return the ordered range of matching subscriptions 211 */ 212 public java.util.List<Subscription> findByG_U(long groupId, long userId, 213 int start, int end, 214 com.liferay.portal.kernel.util.OrderByComparator<Subscription> orderByComparator); 215 216 /** 217 * Returns an ordered range of all the subscriptions where groupId = ? and userId = ?. 218 * 219 * <p> 220 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SubscriptionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 221 * </p> 222 * 223 * @param groupId the group ID 224 * @param userId the user ID 225 * @param start the lower bound of the range of subscriptions 226 * @param end the upper bound of the range of subscriptions (not inclusive) 227 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 228 * @param retrieveFromCache whether to retrieve from the finder cache 229 * @return the ordered range of matching subscriptions 230 */ 231 public java.util.List<Subscription> findByG_U(long groupId, long userId, 232 int start, int end, 233 com.liferay.portal.kernel.util.OrderByComparator<Subscription> orderByComparator, 234 boolean retrieveFromCache); 235 236 /** 237 * Returns the first subscription in the ordered set where groupId = ? and userId = ?. 238 * 239 * @param groupId the group ID 240 * @param userId the user ID 241 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 242 * @return the first matching subscription 243 * @throws NoSuchSubscriptionException if a matching subscription could not be found 244 */ 245 public Subscription findByG_U_First(long groupId, long userId, 246 com.liferay.portal.kernel.util.OrderByComparator<Subscription> orderByComparator) 247 throws com.liferay.portal.exception.NoSuchSubscriptionException; 248 249 /** 250 * Returns the first subscription in the ordered set where groupId = ? and userId = ?. 251 * 252 * @param groupId the group ID 253 * @param userId the user ID 254 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 255 * @return the first matching subscription, or <code>null</code> if a matching subscription could not be found 256 */ 257 public Subscription fetchByG_U_First(long groupId, long userId, 258 com.liferay.portal.kernel.util.OrderByComparator<Subscription> orderByComparator); 259 260 /** 261 * Returns the last subscription in the ordered set where groupId = ? and userId = ?. 262 * 263 * @param groupId the group ID 264 * @param userId the user ID 265 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 266 * @return the last matching subscription 267 * @throws NoSuchSubscriptionException if a matching subscription could not be found 268 */ 269 public Subscription findByG_U_Last(long groupId, long userId, 270 com.liferay.portal.kernel.util.OrderByComparator<Subscription> orderByComparator) 271 throws com.liferay.portal.exception.NoSuchSubscriptionException; 272 273 /** 274 * Returns the last subscription in the ordered set where groupId = ? and userId = ?. 275 * 276 * @param groupId the group ID 277 * @param userId the user ID 278 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 279 * @return the last matching subscription, or <code>null</code> if a matching subscription could not be found 280 */ 281 public Subscription fetchByG_U_Last(long groupId, long userId, 282 com.liferay.portal.kernel.util.OrderByComparator<Subscription> orderByComparator); 283 284 /** 285 * Returns the subscriptions before and after the current subscription in the ordered set where groupId = ? and userId = ?. 286 * 287 * @param subscriptionId the primary key of the current subscription 288 * @param groupId the group ID 289 * @param userId the user ID 290 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 291 * @return the previous, current, and next subscription 292 * @throws NoSuchSubscriptionException if a subscription with the primary key could not be found 293 */ 294 public Subscription[] findByG_U_PrevAndNext(long subscriptionId, 295 long groupId, long userId, 296 com.liferay.portal.kernel.util.OrderByComparator<Subscription> orderByComparator) 297 throws com.liferay.portal.exception.NoSuchSubscriptionException; 298 299 /** 300 * Removes all the subscriptions where groupId = ? and userId = ? from the database. 301 * 302 * @param groupId the group ID 303 * @param userId the user ID 304 */ 305 public void removeByG_U(long groupId, long userId); 306 307 /** 308 * Returns the number of subscriptions where groupId = ? and userId = ?. 309 * 310 * @param groupId the group ID 311 * @param userId the user ID 312 * @return the number of matching subscriptions 313 */ 314 public int countByG_U(long groupId, long userId); 315 316 /** 317 * Returns all the subscriptions where userId = ? and classNameId = ?. 318 * 319 * @param userId the user ID 320 * @param classNameId the class name ID 321 * @return the matching subscriptions 322 */ 323 public java.util.List<Subscription> findByU_C(long userId, long classNameId); 324 325 /** 326 * Returns a range of all the subscriptions where userId = ? and classNameId = ?. 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 SubscriptionModelImpl}. 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 userId the user ID 333 * @param classNameId the class name ID 334 * @param start the lower bound of the range of subscriptions 335 * @param end the upper bound of the range of subscriptions (not inclusive) 336 * @return the range of matching subscriptions 337 */ 338 public java.util.List<Subscription> findByU_C(long userId, 339 long classNameId, int start, int end); 340 341 /** 342 * Returns an ordered range of all the subscriptions where userId = ? and classNameId = ?. 343 * 344 * <p> 345 * 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 SubscriptionModelImpl}. 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. 346 * </p> 347 * 348 * @param userId the user ID 349 * @param classNameId the class name ID 350 * @param start the lower bound of the range of subscriptions 351 * @param end the upper bound of the range of subscriptions (not inclusive) 352 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 353 * @return the ordered range of matching subscriptions 354 */ 355 public java.util.List<Subscription> findByU_C(long userId, 356 long classNameId, int start, int end, 357 com.liferay.portal.kernel.util.OrderByComparator<Subscription> orderByComparator); 358 359 /** 360 * Returns an ordered range of all the subscriptions where userId = ? and classNameId = ?. 361 * 362 * <p> 363 * 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 SubscriptionModelImpl}. 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. 364 * </p> 365 * 366 * @param userId the user ID 367 * @param classNameId the class name ID 368 * @param start the lower bound of the range of subscriptions 369 * @param end the upper bound of the range of subscriptions (not inclusive) 370 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 371 * @param retrieveFromCache whether to retrieve from the finder cache 372 * @return the ordered range of matching subscriptions 373 */ 374 public java.util.List<Subscription> findByU_C(long userId, 375 long classNameId, int start, int end, 376 com.liferay.portal.kernel.util.OrderByComparator<Subscription> orderByComparator, 377 boolean retrieveFromCache); 378 379 /** 380 * Returns the first subscription in the ordered set where userId = ? and classNameId = ?. 381 * 382 * @param userId the user ID 383 * @param classNameId the class name ID 384 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 385 * @return the first matching subscription 386 * @throws NoSuchSubscriptionException if a matching subscription could not be found 387 */ 388 public Subscription findByU_C_First(long userId, long classNameId, 389 com.liferay.portal.kernel.util.OrderByComparator<Subscription> orderByComparator) 390 throws com.liferay.portal.exception.NoSuchSubscriptionException; 391 392 /** 393 * Returns the first subscription in the ordered set where userId = ? and classNameId = ?. 394 * 395 * @param userId the user ID 396 * @param classNameId the class name ID 397 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 398 * @return the first matching subscription, or <code>null</code> if a matching subscription could not be found 399 */ 400 public Subscription fetchByU_C_First(long userId, long classNameId, 401 com.liferay.portal.kernel.util.OrderByComparator<Subscription> orderByComparator); 402 403 /** 404 * Returns the last subscription in the ordered set where userId = ? and classNameId = ?. 405 * 406 * @param userId the user ID 407 * @param classNameId the class name ID 408 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 409 * @return the last matching subscription 410 * @throws NoSuchSubscriptionException if a matching subscription could not be found 411 */ 412 public Subscription findByU_C_Last(long userId, long classNameId, 413 com.liferay.portal.kernel.util.OrderByComparator<Subscription> orderByComparator) 414 throws com.liferay.portal.exception.NoSuchSubscriptionException; 415 416 /** 417 * Returns the last subscription in the ordered set where userId = ? and classNameId = ?. 418 * 419 * @param userId the user ID 420 * @param classNameId the class name ID 421 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 422 * @return the last matching subscription, or <code>null</code> if a matching subscription could not be found 423 */ 424 public Subscription fetchByU_C_Last(long userId, long classNameId, 425 com.liferay.portal.kernel.util.OrderByComparator<Subscription> orderByComparator); 426 427 /** 428 * Returns the subscriptions before and after the current subscription in the ordered set where userId = ? and classNameId = ?. 429 * 430 * @param subscriptionId the primary key of the current subscription 431 * @param userId the user ID 432 * @param classNameId the class name ID 433 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 434 * @return the previous, current, and next subscription 435 * @throws NoSuchSubscriptionException if a subscription with the primary key could not be found 436 */ 437 public Subscription[] findByU_C_PrevAndNext(long subscriptionId, 438 long userId, long classNameId, 439 com.liferay.portal.kernel.util.OrderByComparator<Subscription> orderByComparator) 440 throws com.liferay.portal.exception.NoSuchSubscriptionException; 441 442 /** 443 * Removes all the subscriptions where userId = ? and classNameId = ? from the database. 444 * 445 * @param userId the user ID 446 * @param classNameId the class name ID 447 */ 448 public void removeByU_C(long userId, long classNameId); 449 450 /** 451 * Returns the number of subscriptions where userId = ? and classNameId = ?. 452 * 453 * @param userId the user ID 454 * @param classNameId the class name ID 455 * @return the number of matching subscriptions 456 */ 457 public int countByU_C(long userId, long classNameId); 458 459 /** 460 * Returns all the subscriptions where companyId = ? and classNameId = ? and classPK = ?. 461 * 462 * @param companyId the company ID 463 * @param classNameId the class name ID 464 * @param classPK the class p k 465 * @return the matching subscriptions 466 */ 467 public java.util.List<Subscription> findByC_C_C(long companyId, 468 long classNameId, long classPK); 469 470 /** 471 * Returns a range of all the subscriptions where companyId = ? and classNameId = ? and classPK = ?. 472 * 473 * <p> 474 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SubscriptionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 475 * </p> 476 * 477 * @param companyId the company ID 478 * @param classNameId the class name ID 479 * @param classPK the class p k 480 * @param start the lower bound of the range of subscriptions 481 * @param end the upper bound of the range of subscriptions (not inclusive) 482 * @return the range of matching subscriptions 483 */ 484 public java.util.List<Subscription> findByC_C_C(long companyId, 485 long classNameId, long classPK, int start, int end); 486 487 /** 488 * Returns an ordered range of all the subscriptions where companyId = ? and classNameId = ? and classPK = ?. 489 * 490 * <p> 491 * 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 SubscriptionModelImpl}. 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. 492 * </p> 493 * 494 * @param companyId the company ID 495 * @param classNameId the class name ID 496 * @param classPK the class p k 497 * @param start the lower bound of the range of subscriptions 498 * @param end the upper bound of the range of subscriptions (not inclusive) 499 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 500 * @return the ordered range of matching subscriptions 501 */ 502 public java.util.List<Subscription> findByC_C_C(long companyId, 503 long classNameId, long classPK, int start, int end, 504 com.liferay.portal.kernel.util.OrderByComparator<Subscription> orderByComparator); 505 506 /** 507 * Returns an ordered range of all the subscriptions where companyId = ? and classNameId = ? and classPK = ?. 508 * 509 * <p> 510 * 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 SubscriptionModelImpl}. 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. 511 * </p> 512 * 513 * @param companyId the company ID 514 * @param classNameId the class name ID 515 * @param classPK the class p k 516 * @param start the lower bound of the range of subscriptions 517 * @param end the upper bound of the range of subscriptions (not inclusive) 518 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 519 * @param retrieveFromCache whether to retrieve from the finder cache 520 * @return the ordered range of matching subscriptions 521 */ 522 public java.util.List<Subscription> findByC_C_C(long companyId, 523 long classNameId, long classPK, int start, int end, 524 com.liferay.portal.kernel.util.OrderByComparator<Subscription> orderByComparator, 525 boolean retrieveFromCache); 526 527 /** 528 * Returns the first subscription in the ordered set where companyId = ? and classNameId = ? and classPK = ?. 529 * 530 * @param companyId the company ID 531 * @param classNameId the class name ID 532 * @param classPK the class p k 533 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 534 * @return the first matching subscription 535 * @throws NoSuchSubscriptionException if a matching subscription could not be found 536 */ 537 public Subscription findByC_C_C_First(long companyId, long classNameId, 538 long classPK, 539 com.liferay.portal.kernel.util.OrderByComparator<Subscription> orderByComparator) 540 throws com.liferay.portal.exception.NoSuchSubscriptionException; 541 542 /** 543 * Returns the first subscription in the ordered set where companyId = ? and classNameId = ? and classPK = ?. 544 * 545 * @param companyId the company ID 546 * @param classNameId the class name ID 547 * @param classPK the class p k 548 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 549 * @return the first matching subscription, or <code>null</code> if a matching subscription could not be found 550 */ 551 public Subscription fetchByC_C_C_First(long companyId, long classNameId, 552 long classPK, 553 com.liferay.portal.kernel.util.OrderByComparator<Subscription> orderByComparator); 554 555 /** 556 * Returns the last subscription in the ordered set where companyId = ? and classNameId = ? and classPK = ?. 557 * 558 * @param companyId the company ID 559 * @param classNameId the class name ID 560 * @param classPK the class p k 561 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 562 * @return the last matching subscription 563 * @throws NoSuchSubscriptionException if a matching subscription could not be found 564 */ 565 public Subscription findByC_C_C_Last(long companyId, long classNameId, 566 long classPK, 567 com.liferay.portal.kernel.util.OrderByComparator<Subscription> orderByComparator) 568 throws com.liferay.portal.exception.NoSuchSubscriptionException; 569 570 /** 571 * Returns the last subscription in the ordered set where companyId = ? and classNameId = ? and classPK = ?. 572 * 573 * @param companyId the company ID 574 * @param classNameId the class name ID 575 * @param classPK the class p k 576 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 577 * @return the last matching subscription, or <code>null</code> if a matching subscription could not be found 578 */ 579 public Subscription fetchByC_C_C_Last(long companyId, long classNameId, 580 long classPK, 581 com.liferay.portal.kernel.util.OrderByComparator<Subscription> orderByComparator); 582 583 /** 584 * Returns the subscriptions before and after the current subscription in the ordered set where companyId = ? and classNameId = ? and classPK = ?. 585 * 586 * @param subscriptionId the primary key of the current subscription 587 * @param companyId the company ID 588 * @param classNameId the class name ID 589 * @param classPK the class p k 590 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 591 * @return the previous, current, and next subscription 592 * @throws NoSuchSubscriptionException if a subscription with the primary key could not be found 593 */ 594 public Subscription[] findByC_C_C_PrevAndNext(long subscriptionId, 595 long companyId, long classNameId, long classPK, 596 com.liferay.portal.kernel.util.OrderByComparator<Subscription> orderByComparator) 597 throws com.liferay.portal.exception.NoSuchSubscriptionException; 598 599 /** 600 * Removes all the subscriptions where companyId = ? and classNameId = ? and classPK = ? from the database. 601 * 602 * @param companyId the company ID 603 * @param classNameId the class name ID 604 * @param classPK the class p k 605 */ 606 public void removeByC_C_C(long companyId, long classNameId, long classPK); 607 608 /** 609 * Returns the number of subscriptions where companyId = ? and classNameId = ? and classPK = ?. 610 * 611 * @param companyId the company ID 612 * @param classNameId the class name ID 613 * @param classPK the class p k 614 * @return the number of matching subscriptions 615 */ 616 public int countByC_C_C(long companyId, long classNameId, long classPK); 617 618 /** 619 * Returns all the subscriptions where companyId = ? and userId = ? and classNameId = ? and classPK = any ?. 620 * 621 * <p> 622 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SubscriptionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 623 * </p> 624 * 625 * @param companyId the company ID 626 * @param userId the user ID 627 * @param classNameId the class name ID 628 * @param classPKs the class p ks 629 * @return the matching subscriptions 630 */ 631 public java.util.List<Subscription> findByC_U_C_C(long companyId, 632 long userId, long classNameId, long[] classPKs); 633 634 /** 635 * Returns a range of all the subscriptions where companyId = ? and userId = ? and classNameId = ? and classPK = any ?. 636 * 637 * <p> 638 * 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 SubscriptionModelImpl}. 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. 639 * </p> 640 * 641 * @param companyId the company ID 642 * @param userId the user ID 643 * @param classNameId the class name ID 644 * @param classPKs the class p ks 645 * @param start the lower bound of the range of subscriptions 646 * @param end the upper bound of the range of subscriptions (not inclusive) 647 * @return the range of matching subscriptions 648 */ 649 public java.util.List<Subscription> findByC_U_C_C(long companyId, 650 long userId, long classNameId, long[] classPKs, int start, int end); 651 652 /** 653 * Returns an ordered range of all the subscriptions where companyId = ? and userId = ? and classNameId = ? and classPK = any ?. 654 * 655 * <p> 656 * 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 SubscriptionModelImpl}. 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. 657 * </p> 658 * 659 * @param companyId the company ID 660 * @param userId the user ID 661 * @param classNameId the class name ID 662 * @param classPKs the class p ks 663 * @param start the lower bound of the range of subscriptions 664 * @param end the upper bound of the range of subscriptions (not inclusive) 665 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 666 * @return the ordered range of matching subscriptions 667 */ 668 public java.util.List<Subscription> findByC_U_C_C(long companyId, 669 long userId, long classNameId, long[] classPKs, int start, int end, 670 com.liferay.portal.kernel.util.OrderByComparator<Subscription> orderByComparator); 671 672 /** 673 * Returns an ordered range of all the subscriptions where companyId = ? and userId = ? and classNameId = ? and classPK = ?, optionally using the finder cache. 674 * 675 * <p> 676 * 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 SubscriptionModelImpl}. 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. 677 * </p> 678 * 679 * @param companyId the company ID 680 * @param userId the user ID 681 * @param classNameId the class name ID 682 * @param classPK the class p k 683 * @param start the lower bound of the range of subscriptions 684 * @param end the upper bound of the range of subscriptions (not inclusive) 685 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 686 * @param retrieveFromCache whether to retrieve from the finder cache 687 * @return the ordered range of matching subscriptions 688 */ 689 public java.util.List<Subscription> findByC_U_C_C(long companyId, 690 long userId, long classNameId, long[] classPKs, int start, int end, 691 com.liferay.portal.kernel.util.OrderByComparator<Subscription> orderByComparator, 692 boolean retrieveFromCache); 693 694 /** 695 * Returns the subscription where companyId = ? and userId = ? and classNameId = ? and classPK = ? or throws a {@link NoSuchSubscriptionException} if it could not be found. 696 * 697 * @param companyId the company ID 698 * @param userId the user ID 699 * @param classNameId the class name ID 700 * @param classPK the class p k 701 * @return the matching subscription 702 * @throws NoSuchSubscriptionException if a matching subscription could not be found 703 */ 704 public Subscription findByC_U_C_C(long companyId, long userId, 705 long classNameId, long classPK) 706 throws com.liferay.portal.exception.NoSuchSubscriptionException; 707 708 /** 709 * Returns the subscription where companyId = ? and userId = ? and classNameId = ? and classPK = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 710 * 711 * @param companyId the company ID 712 * @param userId the user ID 713 * @param classNameId the class name ID 714 * @param classPK the class p k 715 * @return the matching subscription, or <code>null</code> if a matching subscription could not be found 716 */ 717 public Subscription fetchByC_U_C_C(long companyId, long userId, 718 long classNameId, long classPK); 719 720 /** 721 * Returns the subscription where companyId = ? and userId = ? and classNameId = ? and classPK = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 722 * 723 * @param companyId the company ID 724 * @param userId the user ID 725 * @param classNameId the class name ID 726 * @param classPK the class p k 727 * @param retrieveFromCache whether to retrieve from the finder cache 728 * @return the matching subscription, or <code>null</code> if a matching subscription could not be found 729 */ 730 public Subscription fetchByC_U_C_C(long companyId, long userId, 731 long classNameId, long classPK, boolean retrieveFromCache); 732 733 /** 734 * Removes the subscription where companyId = ? and userId = ? and classNameId = ? and classPK = ? from the database. 735 * 736 * @param companyId the company ID 737 * @param userId the user ID 738 * @param classNameId the class name ID 739 * @param classPK the class p k 740 * @return the subscription that was removed 741 */ 742 public Subscription removeByC_U_C_C(long companyId, long userId, 743 long classNameId, long classPK) 744 throws com.liferay.portal.exception.NoSuchSubscriptionException; 745 746 /** 747 * Returns the number of subscriptions where companyId = ? and userId = ? and classNameId = ? and classPK = ?. 748 * 749 * @param companyId the company ID 750 * @param userId the user ID 751 * @param classNameId the class name ID 752 * @param classPK the class p k 753 * @return the number of matching subscriptions 754 */ 755 public int countByC_U_C_C(long companyId, long userId, long classNameId, 756 long classPK); 757 758 /** 759 * Returns the number of subscriptions where companyId = ? and userId = ? and classNameId = ? and classPK = any ?. 760 * 761 * @param companyId the company ID 762 * @param userId the user ID 763 * @param classNameId the class name ID 764 * @param classPKs the class p ks 765 * @return the number of matching subscriptions 766 */ 767 public int countByC_U_C_C(long companyId, long userId, long classNameId, 768 long[] classPKs); 769 770 /** 771 * Caches the subscription in the entity cache if it is enabled. 772 * 773 * @param subscription the subscription 774 */ 775 public void cacheResult(Subscription subscription); 776 777 /** 778 * Caches the subscriptions in the entity cache if it is enabled. 779 * 780 * @param subscriptions the subscriptions 781 */ 782 public void cacheResult(java.util.List<Subscription> subscriptions); 783 784 /** 785 * Creates a new subscription with the primary key. Does not add the subscription to the database. 786 * 787 * @param subscriptionId the primary key for the new subscription 788 * @return the new subscription 789 */ 790 public Subscription create(long subscriptionId); 791 792 /** 793 * Removes the subscription with the primary key from the database. Also notifies the appropriate model listeners. 794 * 795 * @param subscriptionId the primary key of the subscription 796 * @return the subscription that was removed 797 * @throws NoSuchSubscriptionException if a subscription with the primary key could not be found 798 */ 799 public Subscription remove(long subscriptionId) 800 throws com.liferay.portal.exception.NoSuchSubscriptionException; 801 802 public Subscription updateImpl(Subscription subscription); 803 804 /** 805 * Returns the subscription with the primary key or throws a {@link NoSuchSubscriptionException} if it could not be found. 806 * 807 * @param subscriptionId the primary key of the subscription 808 * @return the subscription 809 * @throws NoSuchSubscriptionException if a subscription with the primary key could not be found 810 */ 811 public Subscription findByPrimaryKey(long subscriptionId) 812 throws com.liferay.portal.exception.NoSuchSubscriptionException; 813 814 /** 815 * Returns the subscription with the primary key or returns <code>null</code> if it could not be found. 816 * 817 * @param subscriptionId the primary key of the subscription 818 * @return the subscription, or <code>null</code> if a subscription with the primary key could not be found 819 */ 820 public Subscription fetchByPrimaryKey(long subscriptionId); 821 822 @Override 823 public java.util.Map<java.io.Serializable, Subscription> fetchByPrimaryKeys( 824 java.util.Set<java.io.Serializable> primaryKeys); 825 826 /** 827 * Returns all the subscriptions. 828 * 829 * @return the subscriptions 830 */ 831 public java.util.List<Subscription> findAll(); 832 833 /** 834 * Returns a range of all the subscriptions. 835 * 836 * <p> 837 * 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 SubscriptionModelImpl}. 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. 838 * </p> 839 * 840 * @param start the lower bound of the range of subscriptions 841 * @param end the upper bound of the range of subscriptions (not inclusive) 842 * @return the range of subscriptions 843 */ 844 public java.util.List<Subscription> findAll(int start, int end); 845 846 /** 847 * Returns an ordered range of all the subscriptions. 848 * 849 * <p> 850 * 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 SubscriptionModelImpl}. 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. 851 * </p> 852 * 853 * @param start the lower bound of the range of subscriptions 854 * @param end the upper bound of the range of subscriptions (not inclusive) 855 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 856 * @return the ordered range of subscriptions 857 */ 858 public java.util.List<Subscription> findAll(int start, int end, 859 com.liferay.portal.kernel.util.OrderByComparator<Subscription> orderByComparator); 860 861 /** 862 * Returns an ordered range of all the subscriptions. 863 * 864 * <p> 865 * 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 SubscriptionModelImpl}. 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. 866 * </p> 867 * 868 * @param start the lower bound of the range of subscriptions 869 * @param end the upper bound of the range of subscriptions (not inclusive) 870 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 871 * @param retrieveFromCache whether to retrieve from the finder cache 872 * @return the ordered range of subscriptions 873 */ 874 public java.util.List<Subscription> findAll(int start, int end, 875 com.liferay.portal.kernel.util.OrderByComparator<Subscription> orderByComparator, 876 boolean retrieveFromCache); 877 878 /** 879 * Removes all the subscriptions from the database. 880 */ 881 public void removeAll(); 882 883 /** 884 * Returns the number of subscriptions. 885 * 886 * @return the number of subscriptions 887 */ 888 public int countAll(); 889 }