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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63; 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 = &#63;.
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 = &#63; and userId = &#63;.
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 = &#63; and userId = &#63;.
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 = &#63; and userId = &#63;.
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 = &#63; and userId = &#63;.
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 = &#63; and userId = &#63;.
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 = &#63; and userId = &#63;.
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 = &#63; and userId = &#63;.
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 = &#63; and userId = &#63;.
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 = &#63; and userId = &#63;.
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 = &#63; and userId = &#63; 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 = &#63; and userId = &#63;.
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 = &#63; and classNameId = &#63;.
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 = &#63; and classNameId = &#63;.
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 = &#63; and classNameId = &#63;.
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 = &#63; and classNameId = &#63;.
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 = &#63; and classNameId = &#63;.
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 = &#63; and classNameId = &#63;.
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 = &#63; and classNameId = &#63;.
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 = &#63; and classNameId = &#63;.
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 = &#63; and classNameId = &#63;.
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 = &#63; and classNameId = &#63; 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 = &#63; and classNameId = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; 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 = &#63; and classNameId = &#63; and classPK = &#63;.
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 = &#63; and userId = &#63; and classNameId = &#63; and classPK = any &#63;.
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 = &#63; and userId = &#63; and classNameId = &#63; and classPK = any &#63;.
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 = &#63; and userId = &#63; and classNameId = &#63; and classPK = any &#63;.
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 = &#63; and userId = &#63; and classNameId = &#63; and classPK = &#63;, 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 = &#63; and userId = &#63; and classNameId = &#63; and classPK = &#63; 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 = &#63; and userId = &#63; and classNameId = &#63; and classPK = &#63; 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 = &#63; and userId = &#63; and classNameId = &#63; and classPK = &#63; 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 = &#63; and userId = &#63; and classNameId = &#63; and classPK = &#63; 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 = &#63; and userId = &#63; and classNameId = &#63; and classPK = &#63;.
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 = &#63; and userId = &#63; and classNameId = &#63; and classPK = any &#63;.
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    }