001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.messageboards.service.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.service.persistence.BasePersistence;
020    
021    import com.liferay.portlet.messageboards.model.MBMessage;
022    
023    /**
024     * The persistence interface for the message-boards message service.
025     *
026     * <p>
027     * Caching information and settings can be found in <code>portal.properties</code>
028     * </p>
029     *
030     * @author Brian Wing Shun Chan
031     * @see com.liferay.portlet.messageboards.service.persistence.impl.MBMessagePersistenceImpl
032     * @see MBMessageUtil
033     * @generated
034     */
035    @ProviderType
036    public interface MBMessagePersistence extends BasePersistence<MBMessage> {
037            /*
038             * NOTE FOR DEVELOPERS:
039             *
040             * Never modify or reference this interface directly. Always use {@link MBMessageUtil} to access the message-boards message persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface.
041             */
042    
043            /**
044            * Returns all the message-boards messages where uuid = &#63;.
045            *
046            * @param uuid the uuid
047            * @return the matching message-boards messages
048            */
049            public java.util.List<MBMessage> findByUuid(java.lang.String uuid);
050    
051            /**
052            * Returns a range of all the message-boards messages where uuid = &#63;.
053            *
054            * <p>
055            * 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 MBMessageModelImpl}. 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.
056            * </p>
057            *
058            * @param uuid the uuid
059            * @param start the lower bound of the range of message-boards messages
060            * @param end the upper bound of the range of message-boards messages (not inclusive)
061            * @return the range of matching message-boards messages
062            */
063            public java.util.List<MBMessage> findByUuid(java.lang.String uuid,
064                    int start, int end);
065    
066            /**
067            * Returns an ordered range of all the message-boards messages where uuid = &#63;.
068            *
069            * <p>
070            * 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 MBMessageModelImpl}. 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.
071            * </p>
072            *
073            * @param uuid the uuid
074            * @param start the lower bound of the range of message-boards messages
075            * @param end the upper bound of the range of message-boards messages (not inclusive)
076            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
077            * @return the ordered range of matching message-boards messages
078            */
079            public java.util.List<MBMessage> findByUuid(java.lang.String uuid,
080                    int start, int end,
081                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
082    
083            /**
084            * Returns an ordered range of all the message-boards messages where uuid = &#63;.
085            *
086            * <p>
087            * 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 MBMessageModelImpl}. 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.
088            * </p>
089            *
090            * @param uuid the uuid
091            * @param start the lower bound of the range of message-boards messages
092            * @param end the upper bound of the range of message-boards messages (not inclusive)
093            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
094            * @param retrieveFromCache whether to retrieve from the finder cache
095            * @return the ordered range of matching message-boards messages
096            */
097            public java.util.List<MBMessage> findByUuid(java.lang.String uuid,
098                    int start, int end,
099                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator,
100                    boolean retrieveFromCache);
101    
102            /**
103            * Returns the first message-boards message in the ordered set where uuid = &#63;.
104            *
105            * @param uuid the uuid
106            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
107            * @return the first matching message-boards message
108            * @throws NoSuchMessageException if a matching message-boards message could not be found
109            */
110            public MBMessage findByUuid_First(java.lang.String uuid,
111                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
112                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
113    
114            /**
115            * Returns the first message-boards message in the ordered set where uuid = &#63;.
116            *
117            * @param uuid the uuid
118            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
119            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
120            */
121            public MBMessage fetchByUuid_First(java.lang.String uuid,
122                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
123    
124            /**
125            * Returns the last message-boards message in the ordered set where uuid = &#63;.
126            *
127            * @param uuid the uuid
128            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
129            * @return the last matching message-boards message
130            * @throws NoSuchMessageException if a matching message-boards message could not be found
131            */
132            public MBMessage findByUuid_Last(java.lang.String uuid,
133                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
134                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
135    
136            /**
137            * Returns the last message-boards message in the ordered set where uuid = &#63;.
138            *
139            * @param uuid the uuid
140            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
141            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
142            */
143            public MBMessage fetchByUuid_Last(java.lang.String uuid,
144                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
145    
146            /**
147            * Returns the message-boards messages before and after the current message-boards message in the ordered set where uuid = &#63;.
148            *
149            * @param messageId the primary key of the current message-boards message
150            * @param uuid the uuid
151            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
152            * @return the previous, current, and next message-boards message
153            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
154            */
155            public MBMessage[] findByUuid_PrevAndNext(long messageId,
156                    java.lang.String uuid,
157                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
158                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
159    
160            /**
161            * Removes all the message-boards messages where uuid = &#63; from the database.
162            *
163            * @param uuid the uuid
164            */
165            public void removeByUuid(java.lang.String uuid);
166    
167            /**
168            * Returns the number of message-boards messages where uuid = &#63;.
169            *
170            * @param uuid the uuid
171            * @return the number of matching message-boards messages
172            */
173            public int countByUuid(java.lang.String uuid);
174    
175            /**
176            * Returns the message-boards message where uuid = &#63; and groupId = &#63; or throws a {@link NoSuchMessageException} if it could not be found.
177            *
178            * @param uuid the uuid
179            * @param groupId the group ID
180            * @return the matching message-boards message
181            * @throws NoSuchMessageException if a matching message-boards message could not be found
182            */
183            public MBMessage findByUUID_G(java.lang.String uuid, long groupId)
184                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
185    
186            /**
187            * Returns the message-boards message where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
188            *
189            * @param uuid the uuid
190            * @param groupId the group ID
191            * @return the matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
192            */
193            public MBMessage fetchByUUID_G(java.lang.String uuid, long groupId);
194    
195            /**
196            * Returns the message-boards message where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
197            *
198            * @param uuid the uuid
199            * @param groupId the group ID
200            * @param retrieveFromCache whether to retrieve from the finder cache
201            * @return the matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
202            */
203            public MBMessage fetchByUUID_G(java.lang.String uuid, long groupId,
204                    boolean retrieveFromCache);
205    
206            /**
207            * Removes the message-boards message where uuid = &#63; and groupId = &#63; from the database.
208            *
209            * @param uuid the uuid
210            * @param groupId the group ID
211            * @return the message-boards message that was removed
212            */
213            public MBMessage removeByUUID_G(java.lang.String uuid, long groupId)
214                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
215    
216            /**
217            * Returns the number of message-boards messages where uuid = &#63; and groupId = &#63;.
218            *
219            * @param uuid the uuid
220            * @param groupId the group ID
221            * @return the number of matching message-boards messages
222            */
223            public int countByUUID_G(java.lang.String uuid, long groupId);
224    
225            /**
226            * Returns all the message-boards messages where uuid = &#63; and companyId = &#63;.
227            *
228            * @param uuid the uuid
229            * @param companyId the company ID
230            * @return the matching message-boards messages
231            */
232            public java.util.List<MBMessage> findByUuid_C(java.lang.String uuid,
233                    long companyId);
234    
235            /**
236            * Returns a range of all the message-boards messages where uuid = &#63; and companyId = &#63;.
237            *
238            * <p>
239            * 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 MBMessageModelImpl}. 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.
240            * </p>
241            *
242            * @param uuid the uuid
243            * @param companyId the company ID
244            * @param start the lower bound of the range of message-boards messages
245            * @param end the upper bound of the range of message-boards messages (not inclusive)
246            * @return the range of matching message-boards messages
247            */
248            public java.util.List<MBMessage> findByUuid_C(java.lang.String uuid,
249                    long companyId, int start, int end);
250    
251            /**
252            * Returns an ordered range of all the message-boards messages where uuid = &#63; and companyId = &#63;.
253            *
254            * <p>
255            * 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 MBMessageModelImpl}. 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.
256            * </p>
257            *
258            * @param uuid the uuid
259            * @param companyId the company ID
260            * @param start the lower bound of the range of message-boards messages
261            * @param end the upper bound of the range of message-boards messages (not inclusive)
262            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
263            * @return the ordered range of matching message-boards messages
264            */
265            public java.util.List<MBMessage> findByUuid_C(java.lang.String uuid,
266                    long companyId, int start, int end,
267                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
268    
269            /**
270            * Returns an ordered range of all the message-boards messages where uuid = &#63; and companyId = &#63;.
271            *
272            * <p>
273            * 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 MBMessageModelImpl}. 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.
274            * </p>
275            *
276            * @param uuid the uuid
277            * @param companyId the company ID
278            * @param start the lower bound of the range of message-boards messages
279            * @param end the upper bound of the range of message-boards messages (not inclusive)
280            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
281            * @param retrieveFromCache whether to retrieve from the finder cache
282            * @return the ordered range of matching message-boards messages
283            */
284            public java.util.List<MBMessage> findByUuid_C(java.lang.String uuid,
285                    long companyId, int start, int end,
286                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator,
287                    boolean retrieveFromCache);
288    
289            /**
290            * Returns the first message-boards message in the ordered set where uuid = &#63; and companyId = &#63;.
291            *
292            * @param uuid the uuid
293            * @param companyId the company ID
294            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
295            * @return the first matching message-boards message
296            * @throws NoSuchMessageException if a matching message-boards message could not be found
297            */
298            public MBMessage findByUuid_C_First(java.lang.String uuid, long companyId,
299                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
300                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
301    
302            /**
303            * Returns the first message-boards message in the ordered set where uuid = &#63; and companyId = &#63;.
304            *
305            * @param uuid the uuid
306            * @param companyId the company ID
307            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
308            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
309            */
310            public MBMessage fetchByUuid_C_First(java.lang.String uuid, long companyId,
311                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
312    
313            /**
314            * Returns the last message-boards message in the ordered set where uuid = &#63; and companyId = &#63;.
315            *
316            * @param uuid the uuid
317            * @param companyId the company ID
318            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
319            * @return the last matching message-boards message
320            * @throws NoSuchMessageException if a matching message-boards message could not be found
321            */
322            public MBMessage findByUuid_C_Last(java.lang.String uuid, long companyId,
323                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
324                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
325    
326            /**
327            * Returns the last message-boards message in the ordered set where uuid = &#63; and companyId = &#63;.
328            *
329            * @param uuid the uuid
330            * @param companyId the company ID
331            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
332            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
333            */
334            public MBMessage fetchByUuid_C_Last(java.lang.String uuid, long companyId,
335                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
336    
337            /**
338            * Returns the message-boards messages before and after the current message-boards message in the ordered set where uuid = &#63; and companyId = &#63;.
339            *
340            * @param messageId the primary key of the current message-boards message
341            * @param uuid the uuid
342            * @param companyId the company ID
343            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
344            * @return the previous, current, and next message-boards message
345            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
346            */
347            public MBMessage[] findByUuid_C_PrevAndNext(long messageId,
348                    java.lang.String uuid, long companyId,
349                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
350                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
351    
352            /**
353            * Removes all the message-boards messages where uuid = &#63; and companyId = &#63; from the database.
354            *
355            * @param uuid the uuid
356            * @param companyId the company ID
357            */
358            public void removeByUuid_C(java.lang.String uuid, long companyId);
359    
360            /**
361            * Returns the number of message-boards messages where uuid = &#63; and companyId = &#63;.
362            *
363            * @param uuid the uuid
364            * @param companyId the company ID
365            * @return the number of matching message-boards messages
366            */
367            public int countByUuid_C(java.lang.String uuid, long companyId);
368    
369            /**
370            * Returns all the message-boards messages where groupId = &#63;.
371            *
372            * @param groupId the group ID
373            * @return the matching message-boards messages
374            */
375            public java.util.List<MBMessage> findByGroupId(long groupId);
376    
377            /**
378            * Returns a range of all the message-boards messages where groupId = &#63;.
379            *
380            * <p>
381            * 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 MBMessageModelImpl}. 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.
382            * </p>
383            *
384            * @param groupId the group ID
385            * @param start the lower bound of the range of message-boards messages
386            * @param end the upper bound of the range of message-boards messages (not inclusive)
387            * @return the range of matching message-boards messages
388            */
389            public java.util.List<MBMessage> findByGroupId(long groupId, int start,
390                    int end);
391    
392            /**
393            * Returns an ordered range of all the message-boards messages where groupId = &#63;.
394            *
395            * <p>
396            * 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 MBMessageModelImpl}. 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.
397            * </p>
398            *
399            * @param groupId the group ID
400            * @param start the lower bound of the range of message-boards messages
401            * @param end the upper bound of the range of message-boards messages (not inclusive)
402            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
403            * @return the ordered range of matching message-boards messages
404            */
405            public java.util.List<MBMessage> findByGroupId(long groupId, int start,
406                    int end,
407                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
408    
409            /**
410            * Returns an ordered range of all the message-boards messages where groupId = &#63;.
411            *
412            * <p>
413            * 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 MBMessageModelImpl}. 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.
414            * </p>
415            *
416            * @param groupId the group ID
417            * @param start the lower bound of the range of message-boards messages
418            * @param end the upper bound of the range of message-boards messages (not inclusive)
419            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
420            * @param retrieveFromCache whether to retrieve from the finder cache
421            * @return the ordered range of matching message-boards messages
422            */
423            public java.util.List<MBMessage> findByGroupId(long groupId, int start,
424                    int end,
425                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator,
426                    boolean retrieveFromCache);
427    
428            /**
429            * Returns the first message-boards message in the ordered set where groupId = &#63;.
430            *
431            * @param groupId the group ID
432            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
433            * @return the first matching message-boards message
434            * @throws NoSuchMessageException if a matching message-boards message could not be found
435            */
436            public MBMessage findByGroupId_First(long groupId,
437                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
438                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
439    
440            /**
441            * Returns the first message-boards message in the ordered set where groupId = &#63;.
442            *
443            * @param groupId the group ID
444            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
445            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
446            */
447            public MBMessage fetchByGroupId_First(long groupId,
448                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
449    
450            /**
451            * Returns the last message-boards message in the ordered set where groupId = &#63;.
452            *
453            * @param groupId the group ID
454            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
455            * @return the last matching message-boards message
456            * @throws NoSuchMessageException if a matching message-boards message could not be found
457            */
458            public MBMessage findByGroupId_Last(long groupId,
459                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
460                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
461    
462            /**
463            * Returns the last message-boards message in the ordered set where groupId = &#63;.
464            *
465            * @param groupId the group ID
466            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
467            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
468            */
469            public MBMessage fetchByGroupId_Last(long groupId,
470                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
471    
472            /**
473            * Returns the message-boards messages before and after the current message-boards message in the ordered set where groupId = &#63;.
474            *
475            * @param messageId the primary key of the current message-boards message
476            * @param groupId the group ID
477            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
478            * @return the previous, current, and next message-boards message
479            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
480            */
481            public MBMessage[] findByGroupId_PrevAndNext(long messageId, long groupId,
482                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
483                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
484    
485            /**
486            * Returns all the message-boards messages that the user has permission to view where groupId = &#63;.
487            *
488            * @param groupId the group ID
489            * @return the matching message-boards messages that the user has permission to view
490            */
491            public java.util.List<MBMessage> filterFindByGroupId(long groupId);
492    
493            /**
494            * Returns a range of all the message-boards messages that the user has permission to view where groupId = &#63;.
495            *
496            * <p>
497            * 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 MBMessageModelImpl}. 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.
498            * </p>
499            *
500            * @param groupId the group ID
501            * @param start the lower bound of the range of message-boards messages
502            * @param end the upper bound of the range of message-boards messages (not inclusive)
503            * @return the range of matching message-boards messages that the user has permission to view
504            */
505            public java.util.List<MBMessage> filterFindByGroupId(long groupId,
506                    int start, int end);
507    
508            /**
509            * Returns an ordered range of all the message-boards messages that the user has permissions to view where groupId = &#63;.
510            *
511            * <p>
512            * 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 MBMessageModelImpl}. 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.
513            * </p>
514            *
515            * @param groupId the group ID
516            * @param start the lower bound of the range of message-boards messages
517            * @param end the upper bound of the range of message-boards messages (not inclusive)
518            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
519            * @return the ordered range of matching message-boards messages that the user has permission to view
520            */
521            public java.util.List<MBMessage> filterFindByGroupId(long groupId,
522                    int start, int end,
523                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
524    
525            /**
526            * Returns the message-boards messages before and after the current message-boards message in the ordered set of message-boards messages that the user has permission to view where groupId = &#63;.
527            *
528            * @param messageId the primary key of the current message-boards message
529            * @param groupId the group ID
530            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
531            * @return the previous, current, and next message-boards message
532            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
533            */
534            public MBMessage[] filterFindByGroupId_PrevAndNext(long messageId,
535                    long groupId,
536                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
537                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
538    
539            /**
540            * Removes all the message-boards messages where groupId = &#63; from the database.
541            *
542            * @param groupId the group ID
543            */
544            public void removeByGroupId(long groupId);
545    
546            /**
547            * Returns the number of message-boards messages where groupId = &#63;.
548            *
549            * @param groupId the group ID
550            * @return the number of matching message-boards messages
551            */
552            public int countByGroupId(long groupId);
553    
554            /**
555            * Returns the number of message-boards messages that the user has permission to view where groupId = &#63;.
556            *
557            * @param groupId the group ID
558            * @return the number of matching message-boards messages that the user has permission to view
559            */
560            public int filterCountByGroupId(long groupId);
561    
562            /**
563            * Returns all the message-boards messages where companyId = &#63;.
564            *
565            * @param companyId the company ID
566            * @return the matching message-boards messages
567            */
568            public java.util.List<MBMessage> findByCompanyId(long companyId);
569    
570            /**
571            * Returns a range of all the message-boards messages where companyId = &#63;.
572            *
573            * <p>
574            * 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 MBMessageModelImpl}. 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.
575            * </p>
576            *
577            * @param companyId the company ID
578            * @param start the lower bound of the range of message-boards messages
579            * @param end the upper bound of the range of message-boards messages (not inclusive)
580            * @return the range of matching message-boards messages
581            */
582            public java.util.List<MBMessage> findByCompanyId(long companyId, int start,
583                    int end);
584    
585            /**
586            * Returns an ordered range of all the message-boards messages where companyId = &#63;.
587            *
588            * <p>
589            * 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 MBMessageModelImpl}. 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.
590            * </p>
591            *
592            * @param companyId the company ID
593            * @param start the lower bound of the range of message-boards messages
594            * @param end the upper bound of the range of message-boards messages (not inclusive)
595            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
596            * @return the ordered range of matching message-boards messages
597            */
598            public java.util.List<MBMessage> findByCompanyId(long companyId, int start,
599                    int end,
600                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
601    
602            /**
603            * Returns an ordered range of all the message-boards messages where companyId = &#63;.
604            *
605            * <p>
606            * 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 MBMessageModelImpl}. 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.
607            * </p>
608            *
609            * @param companyId the company ID
610            * @param start the lower bound of the range of message-boards messages
611            * @param end the upper bound of the range of message-boards messages (not inclusive)
612            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
613            * @param retrieveFromCache whether to retrieve from the finder cache
614            * @return the ordered range of matching message-boards messages
615            */
616            public java.util.List<MBMessage> findByCompanyId(long companyId, int start,
617                    int end,
618                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator,
619                    boolean retrieveFromCache);
620    
621            /**
622            * Returns the first message-boards message in the ordered set where companyId = &#63;.
623            *
624            * @param companyId the company ID
625            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
626            * @return the first matching message-boards message
627            * @throws NoSuchMessageException if a matching message-boards message could not be found
628            */
629            public MBMessage findByCompanyId_First(long companyId,
630                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
631                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
632    
633            /**
634            * Returns the first message-boards message in the ordered set where companyId = &#63;.
635            *
636            * @param companyId the company ID
637            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
638            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
639            */
640            public MBMessage fetchByCompanyId_First(long companyId,
641                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
642    
643            /**
644            * Returns the last message-boards message in the ordered set where companyId = &#63;.
645            *
646            * @param companyId the company ID
647            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
648            * @return the last matching message-boards message
649            * @throws NoSuchMessageException if a matching message-boards message could not be found
650            */
651            public MBMessage findByCompanyId_Last(long companyId,
652                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
653                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
654    
655            /**
656            * Returns the last message-boards message in the ordered set where companyId = &#63;.
657            *
658            * @param companyId the company ID
659            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
660            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
661            */
662            public MBMessage fetchByCompanyId_Last(long companyId,
663                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
664    
665            /**
666            * Returns the message-boards messages before and after the current message-boards message in the ordered set where companyId = &#63;.
667            *
668            * @param messageId the primary key of the current message-boards message
669            * @param companyId the company ID
670            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
671            * @return the previous, current, and next message-boards message
672            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
673            */
674            public MBMessage[] findByCompanyId_PrevAndNext(long messageId,
675                    long companyId,
676                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
677                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
678    
679            /**
680            * Removes all the message-boards messages where companyId = &#63; from the database.
681            *
682            * @param companyId the company ID
683            */
684            public void removeByCompanyId(long companyId);
685    
686            /**
687            * Returns the number of message-boards messages where companyId = &#63;.
688            *
689            * @param companyId the company ID
690            * @return the number of matching message-boards messages
691            */
692            public int countByCompanyId(long companyId);
693    
694            /**
695            * Returns all the message-boards messages where userId = &#63;.
696            *
697            * @param userId the user ID
698            * @return the matching message-boards messages
699            */
700            public java.util.List<MBMessage> findByUserId(long userId);
701    
702            /**
703            * Returns a range of all the message-boards messages where userId = &#63;.
704            *
705            * <p>
706            * 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 MBMessageModelImpl}. 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.
707            * </p>
708            *
709            * @param userId the user ID
710            * @param start the lower bound of the range of message-boards messages
711            * @param end the upper bound of the range of message-boards messages (not inclusive)
712            * @return the range of matching message-boards messages
713            */
714            public java.util.List<MBMessage> findByUserId(long userId, int start,
715                    int end);
716    
717            /**
718            * Returns an ordered range of all the message-boards messages where userId = &#63;.
719            *
720            * <p>
721            * 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 MBMessageModelImpl}. 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.
722            * </p>
723            *
724            * @param userId the user ID
725            * @param start the lower bound of the range of message-boards messages
726            * @param end the upper bound of the range of message-boards messages (not inclusive)
727            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
728            * @return the ordered range of matching message-boards messages
729            */
730            public java.util.List<MBMessage> findByUserId(long userId, int start,
731                    int end,
732                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
733    
734            /**
735            * Returns an ordered range of all the message-boards messages where userId = &#63;.
736            *
737            * <p>
738            * 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 MBMessageModelImpl}. 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.
739            * </p>
740            *
741            * @param userId the user ID
742            * @param start the lower bound of the range of message-boards messages
743            * @param end the upper bound of the range of message-boards messages (not inclusive)
744            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
745            * @param retrieveFromCache whether to retrieve from the finder cache
746            * @return the ordered range of matching message-boards messages
747            */
748            public java.util.List<MBMessage> findByUserId(long userId, int start,
749                    int end,
750                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator,
751                    boolean retrieveFromCache);
752    
753            /**
754            * Returns the first message-boards message in the ordered set where userId = &#63;.
755            *
756            * @param userId the user ID
757            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
758            * @return the first matching message-boards message
759            * @throws NoSuchMessageException if a matching message-boards message could not be found
760            */
761            public MBMessage findByUserId_First(long userId,
762                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
763                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
764    
765            /**
766            * Returns the first message-boards message in the ordered set where userId = &#63;.
767            *
768            * @param userId the user ID
769            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
770            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
771            */
772            public MBMessage fetchByUserId_First(long userId,
773                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
774    
775            /**
776            * Returns the last message-boards message in the ordered set where userId = &#63;.
777            *
778            * @param userId the user ID
779            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
780            * @return the last matching message-boards message
781            * @throws NoSuchMessageException if a matching message-boards message could not be found
782            */
783            public MBMessage findByUserId_Last(long userId,
784                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
785                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
786    
787            /**
788            * Returns the last message-boards message in the ordered set where userId = &#63;.
789            *
790            * @param userId the user ID
791            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
792            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
793            */
794            public MBMessage fetchByUserId_Last(long userId,
795                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
796    
797            /**
798            * Returns the message-boards messages before and after the current message-boards message in the ordered set where userId = &#63;.
799            *
800            * @param messageId the primary key of the current message-boards message
801            * @param userId the user ID
802            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
803            * @return the previous, current, and next message-boards message
804            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
805            */
806            public MBMessage[] findByUserId_PrevAndNext(long messageId, long userId,
807                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
808                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
809    
810            /**
811            * Removes all the message-boards messages where userId = &#63; from the database.
812            *
813            * @param userId the user ID
814            */
815            public void removeByUserId(long userId);
816    
817            /**
818            * Returns the number of message-boards messages where userId = &#63;.
819            *
820            * @param userId the user ID
821            * @return the number of matching message-boards messages
822            */
823            public int countByUserId(long userId);
824    
825            /**
826            * Returns all the message-boards messages where threadId = &#63;.
827            *
828            * @param threadId the thread ID
829            * @return the matching message-boards messages
830            */
831            public java.util.List<MBMessage> findByThreadId(long threadId);
832    
833            /**
834            * Returns a range of all the message-boards messages where threadId = &#63;.
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 MBMessageModelImpl}. 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 threadId the thread ID
841            * @param start the lower bound of the range of message-boards messages
842            * @param end the upper bound of the range of message-boards messages (not inclusive)
843            * @return the range of matching message-boards messages
844            */
845            public java.util.List<MBMessage> findByThreadId(long threadId, int start,
846                    int end);
847    
848            /**
849            * Returns an ordered range of all the message-boards messages where threadId = &#63;.
850            *
851            * <p>
852            * 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 MBMessageModelImpl}. 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.
853            * </p>
854            *
855            * @param threadId the thread ID
856            * @param start the lower bound of the range of message-boards messages
857            * @param end the upper bound of the range of message-boards messages (not inclusive)
858            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
859            * @return the ordered range of matching message-boards messages
860            */
861            public java.util.List<MBMessage> findByThreadId(long threadId, int start,
862                    int end,
863                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
864    
865            /**
866            * Returns an ordered range of all the message-boards messages where threadId = &#63;.
867            *
868            * <p>
869            * 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 MBMessageModelImpl}. 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.
870            * </p>
871            *
872            * @param threadId the thread ID
873            * @param start the lower bound of the range of message-boards messages
874            * @param end the upper bound of the range of message-boards messages (not inclusive)
875            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
876            * @param retrieveFromCache whether to retrieve from the finder cache
877            * @return the ordered range of matching message-boards messages
878            */
879            public java.util.List<MBMessage> findByThreadId(long threadId, int start,
880                    int end,
881                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator,
882                    boolean retrieveFromCache);
883    
884            /**
885            * Returns the first message-boards message in the ordered set where threadId = &#63;.
886            *
887            * @param threadId the thread ID
888            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
889            * @return the first matching message-boards message
890            * @throws NoSuchMessageException if a matching message-boards message could not be found
891            */
892            public MBMessage findByThreadId_First(long threadId,
893                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
894                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
895    
896            /**
897            * Returns the first message-boards message in the ordered set where threadId = &#63;.
898            *
899            * @param threadId the thread ID
900            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
901            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
902            */
903            public MBMessage fetchByThreadId_First(long threadId,
904                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
905    
906            /**
907            * Returns the last message-boards message in the ordered set where threadId = &#63;.
908            *
909            * @param threadId the thread ID
910            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
911            * @return the last matching message-boards message
912            * @throws NoSuchMessageException if a matching message-boards message could not be found
913            */
914            public MBMessage findByThreadId_Last(long threadId,
915                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
916                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
917    
918            /**
919            * Returns the last message-boards message in the ordered set where threadId = &#63;.
920            *
921            * @param threadId the thread ID
922            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
923            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
924            */
925            public MBMessage fetchByThreadId_Last(long threadId,
926                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
927    
928            /**
929            * Returns the message-boards messages before and after the current message-boards message in the ordered set where threadId = &#63;.
930            *
931            * @param messageId the primary key of the current message-boards message
932            * @param threadId the thread ID
933            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
934            * @return the previous, current, and next message-boards message
935            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
936            */
937            public MBMessage[] findByThreadId_PrevAndNext(long messageId,
938                    long threadId,
939                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
940                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
941    
942            /**
943            * Removes all the message-boards messages where threadId = &#63; from the database.
944            *
945            * @param threadId the thread ID
946            */
947            public void removeByThreadId(long threadId);
948    
949            /**
950            * Returns the number of message-boards messages where threadId = &#63;.
951            *
952            * @param threadId the thread ID
953            * @return the number of matching message-boards messages
954            */
955            public int countByThreadId(long threadId);
956    
957            /**
958            * Returns all the message-boards messages where threadId = &#63;.
959            *
960            * @param threadId the thread ID
961            * @return the matching message-boards messages
962            */
963            public java.util.List<MBMessage> findByThreadReplies(long threadId);
964    
965            /**
966            * Returns a range of all the message-boards messages where threadId = &#63;.
967            *
968            * <p>
969            * 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 MBMessageModelImpl}. 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.
970            * </p>
971            *
972            * @param threadId the thread ID
973            * @param start the lower bound of the range of message-boards messages
974            * @param end the upper bound of the range of message-boards messages (not inclusive)
975            * @return the range of matching message-boards messages
976            */
977            public java.util.List<MBMessage> findByThreadReplies(long threadId,
978                    int start, int end);
979    
980            /**
981            * Returns an ordered range of all the message-boards messages where threadId = &#63;.
982            *
983            * <p>
984            * 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 MBMessageModelImpl}. 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.
985            * </p>
986            *
987            * @param threadId the thread ID
988            * @param start the lower bound of the range of message-boards messages
989            * @param end the upper bound of the range of message-boards messages (not inclusive)
990            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
991            * @return the ordered range of matching message-boards messages
992            */
993            public java.util.List<MBMessage> findByThreadReplies(long threadId,
994                    int start, int end,
995                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
996    
997            /**
998            * Returns an ordered range of all the message-boards messages where threadId = &#63;.
999            *
1000            * <p>
1001            * 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 MBMessageModelImpl}. 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.
1002            * </p>
1003            *
1004            * @param threadId the thread ID
1005            * @param start the lower bound of the range of message-boards messages
1006            * @param end the upper bound of the range of message-boards messages (not inclusive)
1007            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1008            * @param retrieveFromCache whether to retrieve from the finder cache
1009            * @return the ordered range of matching message-boards messages
1010            */
1011            public java.util.List<MBMessage> findByThreadReplies(long threadId,
1012                    int start, int end,
1013                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator,
1014                    boolean retrieveFromCache);
1015    
1016            /**
1017            * Returns the first message-boards message in the ordered set where threadId = &#63;.
1018            *
1019            * @param threadId the thread ID
1020            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1021            * @return the first matching message-boards message
1022            * @throws NoSuchMessageException if a matching message-boards message could not be found
1023            */
1024            public MBMessage findByThreadReplies_First(long threadId,
1025                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
1026                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
1027    
1028            /**
1029            * Returns the first message-boards message in the ordered set where threadId = &#63;.
1030            *
1031            * @param threadId the thread ID
1032            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1033            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
1034            */
1035            public MBMessage fetchByThreadReplies_First(long threadId,
1036                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
1037    
1038            /**
1039            * Returns the last message-boards message in the ordered set where threadId = &#63;.
1040            *
1041            * @param threadId the thread ID
1042            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1043            * @return the last matching message-boards message
1044            * @throws NoSuchMessageException if a matching message-boards message could not be found
1045            */
1046            public MBMessage findByThreadReplies_Last(long threadId,
1047                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
1048                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
1049    
1050            /**
1051            * Returns the last message-boards message in the ordered set where threadId = &#63;.
1052            *
1053            * @param threadId the thread ID
1054            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1055            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
1056            */
1057            public MBMessage fetchByThreadReplies_Last(long threadId,
1058                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
1059    
1060            /**
1061            * Returns the message-boards messages before and after the current message-boards message in the ordered set where threadId = &#63;.
1062            *
1063            * @param messageId the primary key of the current message-boards message
1064            * @param threadId the thread ID
1065            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1066            * @return the previous, current, and next message-boards message
1067            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
1068            */
1069            public MBMessage[] findByThreadReplies_PrevAndNext(long messageId,
1070                    long threadId,
1071                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
1072                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
1073    
1074            /**
1075            * Removes all the message-boards messages where threadId = &#63; from the database.
1076            *
1077            * @param threadId the thread ID
1078            */
1079            public void removeByThreadReplies(long threadId);
1080    
1081            /**
1082            * Returns the number of message-boards messages where threadId = &#63;.
1083            *
1084            * @param threadId the thread ID
1085            * @return the number of matching message-boards messages
1086            */
1087            public int countByThreadReplies(long threadId);
1088    
1089            /**
1090            * Returns all the message-boards messages where groupId = &#63; and userId = &#63;.
1091            *
1092            * @param groupId the group ID
1093            * @param userId the user ID
1094            * @return the matching message-boards messages
1095            */
1096            public java.util.List<MBMessage> findByG_U(long groupId, long userId);
1097    
1098            /**
1099            * Returns a range of all the message-boards messages where groupId = &#63; and userId = &#63;.
1100            *
1101            * <p>
1102            * 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 MBMessageModelImpl}. 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.
1103            * </p>
1104            *
1105            * @param groupId the group ID
1106            * @param userId the user ID
1107            * @param start the lower bound of the range of message-boards messages
1108            * @param end the upper bound of the range of message-boards messages (not inclusive)
1109            * @return the range of matching message-boards messages
1110            */
1111            public java.util.List<MBMessage> findByG_U(long groupId, long userId,
1112                    int start, int end);
1113    
1114            /**
1115            * Returns an ordered range of all the message-boards messages where groupId = &#63; and userId = &#63;.
1116            *
1117            * <p>
1118            * 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 MBMessageModelImpl}. 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.
1119            * </p>
1120            *
1121            * @param groupId the group ID
1122            * @param userId the user ID
1123            * @param start the lower bound of the range of message-boards messages
1124            * @param end the upper bound of the range of message-boards messages (not inclusive)
1125            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1126            * @return the ordered range of matching message-boards messages
1127            */
1128            public java.util.List<MBMessage> findByG_U(long groupId, long userId,
1129                    int start, int end,
1130                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
1131    
1132            /**
1133            * Returns an ordered range of all the message-boards messages where groupId = &#63; and userId = &#63;.
1134            *
1135            * <p>
1136            * 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 MBMessageModelImpl}. 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.
1137            * </p>
1138            *
1139            * @param groupId the group ID
1140            * @param userId the user ID
1141            * @param start the lower bound of the range of message-boards messages
1142            * @param end the upper bound of the range of message-boards messages (not inclusive)
1143            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1144            * @param retrieveFromCache whether to retrieve from the finder cache
1145            * @return the ordered range of matching message-boards messages
1146            */
1147            public java.util.List<MBMessage> findByG_U(long groupId, long userId,
1148                    int start, int end,
1149                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator,
1150                    boolean retrieveFromCache);
1151    
1152            /**
1153            * Returns the first message-boards message in the ordered set where groupId = &#63; and userId = &#63;.
1154            *
1155            * @param groupId the group ID
1156            * @param userId the user ID
1157            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1158            * @return the first matching message-boards message
1159            * @throws NoSuchMessageException if a matching message-boards message could not be found
1160            */
1161            public MBMessage findByG_U_First(long groupId, long userId,
1162                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
1163                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
1164    
1165            /**
1166            * Returns the first message-boards message in the ordered set where groupId = &#63; and userId = &#63;.
1167            *
1168            * @param groupId the group ID
1169            * @param userId the user ID
1170            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1171            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
1172            */
1173            public MBMessage fetchByG_U_First(long groupId, long userId,
1174                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
1175    
1176            /**
1177            * Returns the last message-boards message in the ordered set where groupId = &#63; and userId = &#63;.
1178            *
1179            * @param groupId the group ID
1180            * @param userId the user ID
1181            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1182            * @return the last matching message-boards message
1183            * @throws NoSuchMessageException if a matching message-boards message could not be found
1184            */
1185            public MBMessage findByG_U_Last(long groupId, long userId,
1186                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
1187                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
1188    
1189            /**
1190            * Returns the last message-boards message in the ordered set where groupId = &#63; and userId = &#63;.
1191            *
1192            * @param groupId the group ID
1193            * @param userId the user ID
1194            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1195            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
1196            */
1197            public MBMessage fetchByG_U_Last(long groupId, long userId,
1198                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
1199    
1200            /**
1201            * Returns the message-boards messages before and after the current message-boards message in the ordered set where groupId = &#63; and userId = &#63;.
1202            *
1203            * @param messageId the primary key of the current message-boards message
1204            * @param groupId the group ID
1205            * @param userId the user ID
1206            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1207            * @return the previous, current, and next message-boards message
1208            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
1209            */
1210            public MBMessage[] findByG_U_PrevAndNext(long messageId, long groupId,
1211                    long userId,
1212                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
1213                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
1214    
1215            /**
1216            * Returns all the message-boards messages that the user has permission to view where groupId = &#63; and userId = &#63;.
1217            *
1218            * @param groupId the group ID
1219            * @param userId the user ID
1220            * @return the matching message-boards messages that the user has permission to view
1221            */
1222            public java.util.List<MBMessage> filterFindByG_U(long groupId, long userId);
1223    
1224            /**
1225            * Returns a range of all the message-boards messages that the user has permission to view where groupId = &#63; and userId = &#63;.
1226            *
1227            * <p>
1228            * 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 MBMessageModelImpl}. 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.
1229            * </p>
1230            *
1231            * @param groupId the group ID
1232            * @param userId the user ID
1233            * @param start the lower bound of the range of message-boards messages
1234            * @param end the upper bound of the range of message-boards messages (not inclusive)
1235            * @return the range of matching message-boards messages that the user has permission to view
1236            */
1237            public java.util.List<MBMessage> filterFindByG_U(long groupId, long userId,
1238                    int start, int end);
1239    
1240            /**
1241            * Returns an ordered range of all the message-boards messages that the user has permissions to view where groupId = &#63; and userId = &#63;.
1242            *
1243            * <p>
1244            * 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 MBMessageModelImpl}. 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.
1245            * </p>
1246            *
1247            * @param groupId the group ID
1248            * @param userId the user ID
1249            * @param start the lower bound of the range of message-boards messages
1250            * @param end the upper bound of the range of message-boards messages (not inclusive)
1251            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1252            * @return the ordered range of matching message-boards messages that the user has permission to view
1253            */
1254            public java.util.List<MBMessage> filterFindByG_U(long groupId, long userId,
1255                    int start, int end,
1256                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
1257    
1258            /**
1259            * Returns the message-boards messages before and after the current message-boards message in the ordered set of message-boards messages that the user has permission to view where groupId = &#63; and userId = &#63;.
1260            *
1261            * @param messageId the primary key of the current message-boards message
1262            * @param groupId the group ID
1263            * @param userId the user ID
1264            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1265            * @return the previous, current, and next message-boards message
1266            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
1267            */
1268            public MBMessage[] filterFindByG_U_PrevAndNext(long messageId,
1269                    long groupId, long userId,
1270                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
1271                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
1272    
1273            /**
1274            * Removes all the message-boards messages where groupId = &#63; and userId = &#63; from the database.
1275            *
1276            * @param groupId the group ID
1277            * @param userId the user ID
1278            */
1279            public void removeByG_U(long groupId, long userId);
1280    
1281            /**
1282            * Returns the number of message-boards messages where groupId = &#63; and userId = &#63;.
1283            *
1284            * @param groupId the group ID
1285            * @param userId the user ID
1286            * @return the number of matching message-boards messages
1287            */
1288            public int countByG_U(long groupId, long userId);
1289    
1290            /**
1291            * Returns the number of message-boards messages that the user has permission to view where groupId = &#63; and userId = &#63;.
1292            *
1293            * @param groupId the group ID
1294            * @param userId the user ID
1295            * @return the number of matching message-boards messages that the user has permission to view
1296            */
1297            public int filterCountByG_U(long groupId, long userId);
1298    
1299            /**
1300            * Returns all the message-boards messages where groupId = &#63; and categoryId = &#63;.
1301            *
1302            * @param groupId the group ID
1303            * @param categoryId the category ID
1304            * @return the matching message-boards messages
1305            */
1306            public java.util.List<MBMessage> findByG_C(long groupId, long categoryId);
1307    
1308            /**
1309            * Returns a range of all the message-boards messages where groupId = &#63; and categoryId = &#63;.
1310            *
1311            * <p>
1312            * 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 MBMessageModelImpl}. 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.
1313            * </p>
1314            *
1315            * @param groupId the group ID
1316            * @param categoryId the category ID
1317            * @param start the lower bound of the range of message-boards messages
1318            * @param end the upper bound of the range of message-boards messages (not inclusive)
1319            * @return the range of matching message-boards messages
1320            */
1321            public java.util.List<MBMessage> findByG_C(long groupId, long categoryId,
1322                    int start, int end);
1323    
1324            /**
1325            * Returns an ordered range of all the message-boards messages where groupId = &#63; and categoryId = &#63;.
1326            *
1327            * <p>
1328            * 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 MBMessageModelImpl}. 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.
1329            * </p>
1330            *
1331            * @param groupId the group ID
1332            * @param categoryId the category ID
1333            * @param start the lower bound of the range of message-boards messages
1334            * @param end the upper bound of the range of message-boards messages (not inclusive)
1335            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1336            * @return the ordered range of matching message-boards messages
1337            */
1338            public java.util.List<MBMessage> findByG_C(long groupId, long categoryId,
1339                    int start, int end,
1340                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
1341    
1342            /**
1343            * Returns an ordered range of all the message-boards messages where groupId = &#63; and categoryId = &#63;.
1344            *
1345            * <p>
1346            * 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 MBMessageModelImpl}. 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.
1347            * </p>
1348            *
1349            * @param groupId the group ID
1350            * @param categoryId the category ID
1351            * @param start the lower bound of the range of message-boards messages
1352            * @param end the upper bound of the range of message-boards messages (not inclusive)
1353            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1354            * @param retrieveFromCache whether to retrieve from the finder cache
1355            * @return the ordered range of matching message-boards messages
1356            */
1357            public java.util.List<MBMessage> findByG_C(long groupId, long categoryId,
1358                    int start, int end,
1359                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator,
1360                    boolean retrieveFromCache);
1361    
1362            /**
1363            * Returns the first message-boards message in the ordered set where groupId = &#63; and categoryId = &#63;.
1364            *
1365            * @param groupId the group ID
1366            * @param categoryId the category ID
1367            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1368            * @return the first matching message-boards message
1369            * @throws NoSuchMessageException if a matching message-boards message could not be found
1370            */
1371            public MBMessage findByG_C_First(long groupId, long categoryId,
1372                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
1373                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
1374    
1375            /**
1376            * Returns the first message-boards message in the ordered set where groupId = &#63; and categoryId = &#63;.
1377            *
1378            * @param groupId the group ID
1379            * @param categoryId the category ID
1380            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1381            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
1382            */
1383            public MBMessage fetchByG_C_First(long groupId, long categoryId,
1384                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
1385    
1386            /**
1387            * Returns the last message-boards message in the ordered set where groupId = &#63; and categoryId = &#63;.
1388            *
1389            * @param groupId the group ID
1390            * @param categoryId the category ID
1391            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1392            * @return the last matching message-boards message
1393            * @throws NoSuchMessageException if a matching message-boards message could not be found
1394            */
1395            public MBMessage findByG_C_Last(long groupId, long categoryId,
1396                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
1397                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
1398    
1399            /**
1400            * Returns the last message-boards message in the ordered set where groupId = &#63; and categoryId = &#63;.
1401            *
1402            * @param groupId the group ID
1403            * @param categoryId the category ID
1404            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1405            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
1406            */
1407            public MBMessage fetchByG_C_Last(long groupId, long categoryId,
1408                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
1409    
1410            /**
1411            * Returns the message-boards messages before and after the current message-boards message in the ordered set where groupId = &#63; and categoryId = &#63;.
1412            *
1413            * @param messageId the primary key of the current message-boards message
1414            * @param groupId the group ID
1415            * @param categoryId the category ID
1416            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1417            * @return the previous, current, and next message-boards message
1418            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
1419            */
1420            public MBMessage[] findByG_C_PrevAndNext(long messageId, long groupId,
1421                    long categoryId,
1422                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
1423                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
1424    
1425            /**
1426            * Returns all the message-boards messages that the user has permission to view where groupId = &#63; and categoryId = &#63;.
1427            *
1428            * @param groupId the group ID
1429            * @param categoryId the category ID
1430            * @return the matching message-boards messages that the user has permission to view
1431            */
1432            public java.util.List<MBMessage> filterFindByG_C(long groupId,
1433                    long categoryId);
1434    
1435            /**
1436            * Returns a range of all the message-boards messages that the user has permission to view where groupId = &#63; and categoryId = &#63;.
1437            *
1438            * <p>
1439            * 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 MBMessageModelImpl}. 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.
1440            * </p>
1441            *
1442            * @param groupId the group ID
1443            * @param categoryId the category ID
1444            * @param start the lower bound of the range of message-boards messages
1445            * @param end the upper bound of the range of message-boards messages (not inclusive)
1446            * @return the range of matching message-boards messages that the user has permission to view
1447            */
1448            public java.util.List<MBMessage> filterFindByG_C(long groupId,
1449                    long categoryId, int start, int end);
1450    
1451            /**
1452            * Returns an ordered range of all the message-boards messages that the user has permissions to view where groupId = &#63; and categoryId = &#63;.
1453            *
1454            * <p>
1455            * 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 MBMessageModelImpl}. 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.
1456            * </p>
1457            *
1458            * @param groupId the group ID
1459            * @param categoryId the category ID
1460            * @param start the lower bound of the range of message-boards messages
1461            * @param end the upper bound of the range of message-boards messages (not inclusive)
1462            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1463            * @return the ordered range of matching message-boards messages that the user has permission to view
1464            */
1465            public java.util.List<MBMessage> filterFindByG_C(long groupId,
1466                    long categoryId, int start, int end,
1467                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
1468    
1469            /**
1470            * Returns the message-boards messages before and after the current message-boards message in the ordered set of message-boards messages that the user has permission to view where groupId = &#63; and categoryId = &#63;.
1471            *
1472            * @param messageId the primary key of the current message-boards message
1473            * @param groupId the group ID
1474            * @param categoryId the category ID
1475            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1476            * @return the previous, current, and next message-boards message
1477            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
1478            */
1479            public MBMessage[] filterFindByG_C_PrevAndNext(long messageId,
1480                    long groupId, long categoryId,
1481                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
1482                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
1483    
1484            /**
1485            * Removes all the message-boards messages where groupId = &#63; and categoryId = &#63; from the database.
1486            *
1487            * @param groupId the group ID
1488            * @param categoryId the category ID
1489            */
1490            public void removeByG_C(long groupId, long categoryId);
1491    
1492            /**
1493            * Returns the number of message-boards messages where groupId = &#63; and categoryId = &#63;.
1494            *
1495            * @param groupId the group ID
1496            * @param categoryId the category ID
1497            * @return the number of matching message-boards messages
1498            */
1499            public int countByG_C(long groupId, long categoryId);
1500    
1501            /**
1502            * Returns the number of message-boards messages that the user has permission to view where groupId = &#63; and categoryId = &#63;.
1503            *
1504            * @param groupId the group ID
1505            * @param categoryId the category ID
1506            * @return the number of matching message-boards messages that the user has permission to view
1507            */
1508            public int filterCountByG_C(long groupId, long categoryId);
1509    
1510            /**
1511            * Returns all the message-boards messages where groupId = &#63; and status = &#63;.
1512            *
1513            * @param groupId the group ID
1514            * @param status the status
1515            * @return the matching message-boards messages
1516            */
1517            public java.util.List<MBMessage> findByG_S(long groupId, int status);
1518    
1519            /**
1520            * Returns a range of all the message-boards messages where groupId = &#63; and status = &#63;.
1521            *
1522            * <p>
1523            * 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 MBMessageModelImpl}. 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.
1524            * </p>
1525            *
1526            * @param groupId the group ID
1527            * @param status the status
1528            * @param start the lower bound of the range of message-boards messages
1529            * @param end the upper bound of the range of message-boards messages (not inclusive)
1530            * @return the range of matching message-boards messages
1531            */
1532            public java.util.List<MBMessage> findByG_S(long groupId, int status,
1533                    int start, int end);
1534    
1535            /**
1536            * Returns an ordered range of all the message-boards messages where groupId = &#63; and status = &#63;.
1537            *
1538            * <p>
1539            * 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 MBMessageModelImpl}. 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.
1540            * </p>
1541            *
1542            * @param groupId the group ID
1543            * @param status the status
1544            * @param start the lower bound of the range of message-boards messages
1545            * @param end the upper bound of the range of message-boards messages (not inclusive)
1546            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1547            * @return the ordered range of matching message-boards messages
1548            */
1549            public java.util.List<MBMessage> findByG_S(long groupId, int status,
1550                    int start, int end,
1551                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
1552    
1553            /**
1554            * Returns an ordered range of all the message-boards messages where groupId = &#63; and status = &#63;.
1555            *
1556            * <p>
1557            * 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 MBMessageModelImpl}. 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.
1558            * </p>
1559            *
1560            * @param groupId the group ID
1561            * @param status the status
1562            * @param start the lower bound of the range of message-boards messages
1563            * @param end the upper bound of the range of message-boards messages (not inclusive)
1564            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1565            * @param retrieveFromCache whether to retrieve from the finder cache
1566            * @return the ordered range of matching message-boards messages
1567            */
1568            public java.util.List<MBMessage> findByG_S(long groupId, int status,
1569                    int start, int end,
1570                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator,
1571                    boolean retrieveFromCache);
1572    
1573            /**
1574            * Returns the first message-boards message in the ordered set where groupId = &#63; and status = &#63;.
1575            *
1576            * @param groupId the group ID
1577            * @param status the status
1578            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1579            * @return the first matching message-boards message
1580            * @throws NoSuchMessageException if a matching message-boards message could not be found
1581            */
1582            public MBMessage findByG_S_First(long groupId, int status,
1583                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
1584                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
1585    
1586            /**
1587            * Returns the first message-boards message in the ordered set where groupId = &#63; and status = &#63;.
1588            *
1589            * @param groupId the group ID
1590            * @param status the status
1591            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1592            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
1593            */
1594            public MBMessage fetchByG_S_First(long groupId, int status,
1595                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
1596    
1597            /**
1598            * Returns the last message-boards message in the ordered set where groupId = &#63; and status = &#63;.
1599            *
1600            * @param groupId the group ID
1601            * @param status the status
1602            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1603            * @return the last matching message-boards message
1604            * @throws NoSuchMessageException if a matching message-boards message could not be found
1605            */
1606            public MBMessage findByG_S_Last(long groupId, int status,
1607                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
1608                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
1609    
1610            /**
1611            * Returns the last message-boards message in the ordered set where groupId = &#63; and status = &#63;.
1612            *
1613            * @param groupId the group ID
1614            * @param status the status
1615            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1616            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
1617            */
1618            public MBMessage fetchByG_S_Last(long groupId, int status,
1619                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
1620    
1621            /**
1622            * Returns the message-boards messages before and after the current message-boards message in the ordered set where groupId = &#63; and status = &#63;.
1623            *
1624            * @param messageId the primary key of the current message-boards message
1625            * @param groupId the group ID
1626            * @param status the status
1627            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1628            * @return the previous, current, and next message-boards message
1629            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
1630            */
1631            public MBMessage[] findByG_S_PrevAndNext(long messageId, long groupId,
1632                    int status,
1633                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
1634                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
1635    
1636            /**
1637            * Returns all the message-boards messages that the user has permission to view where groupId = &#63; and status = &#63;.
1638            *
1639            * @param groupId the group ID
1640            * @param status the status
1641            * @return the matching message-boards messages that the user has permission to view
1642            */
1643            public java.util.List<MBMessage> filterFindByG_S(long groupId, int status);
1644    
1645            /**
1646            * Returns a range of all the message-boards messages that the user has permission to view where groupId = &#63; and status = &#63;.
1647            *
1648            * <p>
1649            * 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 MBMessageModelImpl}. 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.
1650            * </p>
1651            *
1652            * @param groupId the group ID
1653            * @param status the status
1654            * @param start the lower bound of the range of message-boards messages
1655            * @param end the upper bound of the range of message-boards messages (not inclusive)
1656            * @return the range of matching message-boards messages that the user has permission to view
1657            */
1658            public java.util.List<MBMessage> filterFindByG_S(long groupId, int status,
1659                    int start, int end);
1660    
1661            /**
1662            * Returns an ordered range of all the message-boards messages that the user has permissions to view where groupId = &#63; and status = &#63;.
1663            *
1664            * <p>
1665            * 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 MBMessageModelImpl}. 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.
1666            * </p>
1667            *
1668            * @param groupId the group ID
1669            * @param status the status
1670            * @param start the lower bound of the range of message-boards messages
1671            * @param end the upper bound of the range of message-boards messages (not inclusive)
1672            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1673            * @return the ordered range of matching message-boards messages that the user has permission to view
1674            */
1675            public java.util.List<MBMessage> filterFindByG_S(long groupId, int status,
1676                    int start, int end,
1677                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
1678    
1679            /**
1680            * Returns the message-boards messages before and after the current message-boards message in the ordered set of message-boards messages that the user has permission to view where groupId = &#63; and status = &#63;.
1681            *
1682            * @param messageId the primary key of the current message-boards message
1683            * @param groupId the group ID
1684            * @param status the status
1685            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1686            * @return the previous, current, and next message-boards message
1687            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
1688            */
1689            public MBMessage[] filterFindByG_S_PrevAndNext(long messageId,
1690                    long groupId, int status,
1691                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
1692                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
1693    
1694            /**
1695            * Removes all the message-boards messages where groupId = &#63; and status = &#63; from the database.
1696            *
1697            * @param groupId the group ID
1698            * @param status the status
1699            */
1700            public void removeByG_S(long groupId, int status);
1701    
1702            /**
1703            * Returns the number of message-boards messages where groupId = &#63; and status = &#63;.
1704            *
1705            * @param groupId the group ID
1706            * @param status the status
1707            * @return the number of matching message-boards messages
1708            */
1709            public int countByG_S(long groupId, int status);
1710    
1711            /**
1712            * Returns the number of message-boards messages that the user has permission to view where groupId = &#63; and status = &#63;.
1713            *
1714            * @param groupId the group ID
1715            * @param status the status
1716            * @return the number of matching message-boards messages that the user has permission to view
1717            */
1718            public int filterCountByG_S(long groupId, int status);
1719    
1720            /**
1721            * Returns all the message-boards messages where companyId = &#63; and status = &#63;.
1722            *
1723            * @param companyId the company ID
1724            * @param status the status
1725            * @return the matching message-boards messages
1726            */
1727            public java.util.List<MBMessage> findByC_S(long companyId, int status);
1728    
1729            /**
1730            * Returns a range of all the message-boards messages where companyId = &#63; and status = &#63;.
1731            *
1732            * <p>
1733            * 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 MBMessageModelImpl}. 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.
1734            * </p>
1735            *
1736            * @param companyId the company ID
1737            * @param status the status
1738            * @param start the lower bound of the range of message-boards messages
1739            * @param end the upper bound of the range of message-boards messages (not inclusive)
1740            * @return the range of matching message-boards messages
1741            */
1742            public java.util.List<MBMessage> findByC_S(long companyId, int status,
1743                    int start, int end);
1744    
1745            /**
1746            * Returns an ordered range of all the message-boards messages where companyId = &#63; and status = &#63;.
1747            *
1748            * <p>
1749            * 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 MBMessageModelImpl}. 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.
1750            * </p>
1751            *
1752            * @param companyId the company ID
1753            * @param status the status
1754            * @param start the lower bound of the range of message-boards messages
1755            * @param end the upper bound of the range of message-boards messages (not inclusive)
1756            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1757            * @return the ordered range of matching message-boards messages
1758            */
1759            public java.util.List<MBMessage> findByC_S(long companyId, int status,
1760                    int start, int end,
1761                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
1762    
1763            /**
1764            * Returns an ordered range of all the message-boards messages where companyId = &#63; and status = &#63;.
1765            *
1766            * <p>
1767            * 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 MBMessageModelImpl}. 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.
1768            * </p>
1769            *
1770            * @param companyId the company ID
1771            * @param status the status
1772            * @param start the lower bound of the range of message-boards messages
1773            * @param end the upper bound of the range of message-boards messages (not inclusive)
1774            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1775            * @param retrieveFromCache whether to retrieve from the finder cache
1776            * @return the ordered range of matching message-boards messages
1777            */
1778            public java.util.List<MBMessage> findByC_S(long companyId, int status,
1779                    int start, int end,
1780                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator,
1781                    boolean retrieveFromCache);
1782    
1783            /**
1784            * Returns the first message-boards message in the ordered set where companyId = &#63; and status = &#63;.
1785            *
1786            * @param companyId the company ID
1787            * @param status the status
1788            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1789            * @return the first matching message-boards message
1790            * @throws NoSuchMessageException if a matching message-boards message could not be found
1791            */
1792            public MBMessage findByC_S_First(long companyId, int status,
1793                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
1794                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
1795    
1796            /**
1797            * Returns the first message-boards message in the ordered set where companyId = &#63; and status = &#63;.
1798            *
1799            * @param companyId the company ID
1800            * @param status the status
1801            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1802            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
1803            */
1804            public MBMessage fetchByC_S_First(long companyId, int status,
1805                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
1806    
1807            /**
1808            * Returns the last message-boards message in the ordered set where companyId = &#63; and status = &#63;.
1809            *
1810            * @param companyId the company ID
1811            * @param status the status
1812            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1813            * @return the last matching message-boards message
1814            * @throws NoSuchMessageException if a matching message-boards message could not be found
1815            */
1816            public MBMessage findByC_S_Last(long companyId, int status,
1817                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
1818                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
1819    
1820            /**
1821            * Returns the last message-boards message in the ordered set where companyId = &#63; and status = &#63;.
1822            *
1823            * @param companyId the company ID
1824            * @param status the status
1825            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1826            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
1827            */
1828            public MBMessage fetchByC_S_Last(long companyId, int status,
1829                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
1830    
1831            /**
1832            * Returns the message-boards messages before and after the current message-boards message in the ordered set where companyId = &#63; and status = &#63;.
1833            *
1834            * @param messageId the primary key of the current message-boards message
1835            * @param companyId the company ID
1836            * @param status the status
1837            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1838            * @return the previous, current, and next message-boards message
1839            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
1840            */
1841            public MBMessage[] findByC_S_PrevAndNext(long messageId, long companyId,
1842                    int status,
1843                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
1844                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
1845    
1846            /**
1847            * Removes all the message-boards messages where companyId = &#63; and status = &#63; from the database.
1848            *
1849            * @param companyId the company ID
1850            * @param status the status
1851            */
1852            public void removeByC_S(long companyId, int status);
1853    
1854            /**
1855            * Returns the number of message-boards messages where companyId = &#63; and status = &#63;.
1856            *
1857            * @param companyId the company ID
1858            * @param status the status
1859            * @return the number of matching message-boards messages
1860            */
1861            public int countByC_S(long companyId, int status);
1862    
1863            /**
1864            * Returns all the message-boards messages where userId = &#63; and classNameId = &#63;.
1865            *
1866            * @param userId the user ID
1867            * @param classNameId the class name ID
1868            * @return the matching message-boards messages
1869            */
1870            public java.util.List<MBMessage> findByU_C(long userId, long classNameId);
1871    
1872            /**
1873            * Returns a range of all the message-boards messages where userId = &#63; and classNameId = &#63;.
1874            *
1875            * <p>
1876            * 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 MBMessageModelImpl}. 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.
1877            * </p>
1878            *
1879            * @param userId the user ID
1880            * @param classNameId the class name ID
1881            * @param start the lower bound of the range of message-boards messages
1882            * @param end the upper bound of the range of message-boards messages (not inclusive)
1883            * @return the range of matching message-boards messages
1884            */
1885            public java.util.List<MBMessage> findByU_C(long userId, long classNameId,
1886                    int start, int end);
1887    
1888            /**
1889            * Returns an ordered range of all the message-boards messages where userId = &#63; and classNameId = &#63;.
1890            *
1891            * <p>
1892            * 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 MBMessageModelImpl}. 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.
1893            * </p>
1894            *
1895            * @param userId the user ID
1896            * @param classNameId the class name ID
1897            * @param start the lower bound of the range of message-boards messages
1898            * @param end the upper bound of the range of message-boards messages (not inclusive)
1899            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1900            * @return the ordered range of matching message-boards messages
1901            */
1902            public java.util.List<MBMessage> findByU_C(long userId, long classNameId,
1903                    int start, int end,
1904                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
1905    
1906            /**
1907            * Returns an ordered range of all the message-boards messages where userId = &#63; and classNameId = &#63;.
1908            *
1909            * <p>
1910            * 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 MBMessageModelImpl}. 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.
1911            * </p>
1912            *
1913            * @param userId the user ID
1914            * @param classNameId the class name ID
1915            * @param start the lower bound of the range of message-boards messages
1916            * @param end the upper bound of the range of message-boards messages (not inclusive)
1917            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1918            * @param retrieveFromCache whether to retrieve from the finder cache
1919            * @return the ordered range of matching message-boards messages
1920            */
1921            public java.util.List<MBMessage> findByU_C(long userId, long classNameId,
1922                    int start, int end,
1923                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator,
1924                    boolean retrieveFromCache);
1925    
1926            /**
1927            * Returns the first message-boards message in the ordered set where userId = &#63; and classNameId = &#63;.
1928            *
1929            * @param userId the user ID
1930            * @param classNameId the class name ID
1931            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1932            * @return the first matching message-boards message
1933            * @throws NoSuchMessageException if a matching message-boards message could not be found
1934            */
1935            public MBMessage findByU_C_First(long userId, long classNameId,
1936                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
1937                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
1938    
1939            /**
1940            * Returns the first message-boards message in the ordered set where userId = &#63; and classNameId = &#63;.
1941            *
1942            * @param userId the user ID
1943            * @param classNameId the class name ID
1944            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1945            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
1946            */
1947            public MBMessage fetchByU_C_First(long userId, long classNameId,
1948                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
1949    
1950            /**
1951            * Returns the last message-boards message in the ordered set where userId = &#63; and classNameId = &#63;.
1952            *
1953            * @param userId the user ID
1954            * @param classNameId the class name ID
1955            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1956            * @return the last matching message-boards message
1957            * @throws NoSuchMessageException if a matching message-boards message could not be found
1958            */
1959            public MBMessage findByU_C_Last(long userId, long classNameId,
1960                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
1961                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
1962    
1963            /**
1964            * Returns the last message-boards message in the ordered set where userId = &#63; and classNameId = &#63;.
1965            *
1966            * @param userId the user ID
1967            * @param classNameId the class name ID
1968            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1969            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
1970            */
1971            public MBMessage fetchByU_C_Last(long userId, long classNameId,
1972                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
1973    
1974            /**
1975            * Returns the message-boards messages before and after the current message-boards message in the ordered set where userId = &#63; and classNameId = &#63;.
1976            *
1977            * @param messageId the primary key of the current message-boards message
1978            * @param userId the user ID
1979            * @param classNameId the class name ID
1980            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1981            * @return the previous, current, and next message-boards message
1982            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
1983            */
1984            public MBMessage[] findByU_C_PrevAndNext(long messageId, long userId,
1985                    long classNameId,
1986                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
1987                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
1988    
1989            /**
1990            * Returns all the message-boards messages where userId = &#63; and classNameId = any &#63;.
1991            *
1992            * <p>
1993            * 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 MBMessageModelImpl}. 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.
1994            * </p>
1995            *
1996            * @param userId the user ID
1997            * @param classNameIds the class name IDs
1998            * @return the matching message-boards messages
1999            */
2000            public java.util.List<MBMessage> findByU_C(long userId, long[] classNameIds);
2001    
2002            /**
2003            * Returns a range of all the message-boards messages where userId = &#63; and classNameId = any &#63;.
2004            *
2005            * <p>
2006            * 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 MBMessageModelImpl}. 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.
2007            * </p>
2008            *
2009            * @param userId the user ID
2010            * @param classNameIds the class name IDs
2011            * @param start the lower bound of the range of message-boards messages
2012            * @param end the upper bound of the range of message-boards messages (not inclusive)
2013            * @return the range of matching message-boards messages
2014            */
2015            public java.util.List<MBMessage> findByU_C(long userId,
2016                    long[] classNameIds, int start, int end);
2017    
2018            /**
2019            * Returns an ordered range of all the message-boards messages where userId = &#63; and classNameId = any &#63;.
2020            *
2021            * <p>
2022            * 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 MBMessageModelImpl}. 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.
2023            * </p>
2024            *
2025            * @param userId the user ID
2026            * @param classNameIds the class name IDs
2027            * @param start the lower bound of the range of message-boards messages
2028            * @param end the upper bound of the range of message-boards messages (not inclusive)
2029            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2030            * @return the ordered range of matching message-boards messages
2031            */
2032            public java.util.List<MBMessage> findByU_C(long userId,
2033                    long[] classNameIds, int start, int end,
2034                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
2035    
2036            /**
2037            * Returns an ordered range of all the message-boards messages where userId = &#63; and classNameId = &#63;, optionally using the finder cache.
2038            *
2039            * <p>
2040            * 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 MBMessageModelImpl}. 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.
2041            * </p>
2042            *
2043            * @param userId the user ID
2044            * @param classNameId the class name ID
2045            * @param start the lower bound of the range of message-boards messages
2046            * @param end the upper bound of the range of message-boards messages (not inclusive)
2047            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2048            * @param retrieveFromCache whether to retrieve from the finder cache
2049            * @return the ordered range of matching message-boards messages
2050            */
2051            public java.util.List<MBMessage> findByU_C(long userId,
2052                    long[] classNameIds, int start, int end,
2053                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator,
2054                    boolean retrieveFromCache);
2055    
2056            /**
2057            * Removes all the message-boards messages where userId = &#63; and classNameId = &#63; from the database.
2058            *
2059            * @param userId the user ID
2060            * @param classNameId the class name ID
2061            */
2062            public void removeByU_C(long userId, long classNameId);
2063    
2064            /**
2065            * Returns the number of message-boards messages where userId = &#63; and classNameId = &#63;.
2066            *
2067            * @param userId the user ID
2068            * @param classNameId the class name ID
2069            * @return the number of matching message-boards messages
2070            */
2071            public int countByU_C(long userId, long classNameId);
2072    
2073            /**
2074            * Returns the number of message-boards messages where userId = &#63; and classNameId = any &#63;.
2075            *
2076            * @param userId the user ID
2077            * @param classNameIds the class name IDs
2078            * @return the number of matching message-boards messages
2079            */
2080            public int countByU_C(long userId, long[] classNameIds);
2081    
2082            /**
2083            * Returns all the message-boards messages where classNameId = &#63; and classPK = &#63;.
2084            *
2085            * @param classNameId the class name ID
2086            * @param classPK the class p k
2087            * @return the matching message-boards messages
2088            */
2089            public java.util.List<MBMessage> findByC_C(long classNameId, long classPK);
2090    
2091            /**
2092            * Returns a range of all the message-boards messages where classNameId = &#63; and classPK = &#63;.
2093            *
2094            * <p>
2095            * 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 MBMessageModelImpl}. 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.
2096            * </p>
2097            *
2098            * @param classNameId the class name ID
2099            * @param classPK the class p k
2100            * @param start the lower bound of the range of message-boards messages
2101            * @param end the upper bound of the range of message-boards messages (not inclusive)
2102            * @return the range of matching message-boards messages
2103            */
2104            public java.util.List<MBMessage> findByC_C(long classNameId, long classPK,
2105                    int start, int end);
2106    
2107            /**
2108            * Returns an ordered range of all the message-boards messages where classNameId = &#63; and classPK = &#63;.
2109            *
2110            * <p>
2111            * 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 MBMessageModelImpl}. 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.
2112            * </p>
2113            *
2114            * @param classNameId the class name ID
2115            * @param classPK the class p k
2116            * @param start the lower bound of the range of message-boards messages
2117            * @param end the upper bound of the range of message-boards messages (not inclusive)
2118            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2119            * @return the ordered range of matching message-boards messages
2120            */
2121            public java.util.List<MBMessage> findByC_C(long classNameId, long classPK,
2122                    int start, int end,
2123                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
2124    
2125            /**
2126            * Returns an ordered range of all the message-boards messages where classNameId = &#63; and classPK = &#63;.
2127            *
2128            * <p>
2129            * 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 MBMessageModelImpl}. 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.
2130            * </p>
2131            *
2132            * @param classNameId the class name ID
2133            * @param classPK the class p k
2134            * @param start the lower bound of the range of message-boards messages
2135            * @param end the upper bound of the range of message-boards messages (not inclusive)
2136            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2137            * @param retrieveFromCache whether to retrieve from the finder cache
2138            * @return the ordered range of matching message-boards messages
2139            */
2140            public java.util.List<MBMessage> findByC_C(long classNameId, long classPK,
2141                    int start, int end,
2142                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator,
2143                    boolean retrieveFromCache);
2144    
2145            /**
2146            * Returns the first message-boards message in the ordered set where classNameId = &#63; and classPK = &#63;.
2147            *
2148            * @param classNameId the class name ID
2149            * @param classPK the class p k
2150            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2151            * @return the first matching message-boards message
2152            * @throws NoSuchMessageException if a matching message-boards message could not be found
2153            */
2154            public MBMessage findByC_C_First(long classNameId, long classPK,
2155                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
2156                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
2157    
2158            /**
2159            * Returns the first message-boards message in the ordered set where classNameId = &#63; and classPK = &#63;.
2160            *
2161            * @param classNameId the class name ID
2162            * @param classPK the class p k
2163            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2164            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
2165            */
2166            public MBMessage fetchByC_C_First(long classNameId, long classPK,
2167                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
2168    
2169            /**
2170            * Returns the last message-boards message in the ordered set where classNameId = &#63; and classPK = &#63;.
2171            *
2172            * @param classNameId the class name ID
2173            * @param classPK the class p k
2174            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2175            * @return the last matching message-boards message
2176            * @throws NoSuchMessageException if a matching message-boards message could not be found
2177            */
2178            public MBMessage findByC_C_Last(long classNameId, long classPK,
2179                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
2180                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
2181    
2182            /**
2183            * Returns the last message-boards message in the ordered set where classNameId = &#63; and classPK = &#63;.
2184            *
2185            * @param classNameId the class name ID
2186            * @param classPK the class p k
2187            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2188            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
2189            */
2190            public MBMessage fetchByC_C_Last(long classNameId, long classPK,
2191                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
2192    
2193            /**
2194            * Returns the message-boards messages before and after the current message-boards message in the ordered set where classNameId = &#63; and classPK = &#63;.
2195            *
2196            * @param messageId the primary key of the current message-boards message
2197            * @param classNameId the class name ID
2198            * @param classPK the class p k
2199            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2200            * @return the previous, current, and next message-boards message
2201            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
2202            */
2203            public MBMessage[] findByC_C_PrevAndNext(long messageId, long classNameId,
2204                    long classPK,
2205                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
2206                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
2207    
2208            /**
2209            * Removes all the message-boards messages where classNameId = &#63; and classPK = &#63; from the database.
2210            *
2211            * @param classNameId the class name ID
2212            * @param classPK the class p k
2213            */
2214            public void removeByC_C(long classNameId, long classPK);
2215    
2216            /**
2217            * Returns the number of message-boards messages where classNameId = &#63; and classPK = &#63;.
2218            *
2219            * @param classNameId the class name ID
2220            * @param classPK the class p k
2221            * @return the number of matching message-boards messages
2222            */
2223            public int countByC_C(long classNameId, long classPK);
2224    
2225            /**
2226            * Returns all the message-boards messages where threadId = &#63; and parentMessageId = &#63;.
2227            *
2228            * @param threadId the thread ID
2229            * @param parentMessageId the parent message ID
2230            * @return the matching message-boards messages
2231            */
2232            public java.util.List<MBMessage> findByT_P(long threadId,
2233                    long parentMessageId);
2234    
2235            /**
2236            * Returns a range of all the message-boards messages where threadId = &#63; and parentMessageId = &#63;.
2237            *
2238            * <p>
2239            * 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 MBMessageModelImpl}. 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.
2240            * </p>
2241            *
2242            * @param threadId the thread ID
2243            * @param parentMessageId the parent message ID
2244            * @param start the lower bound of the range of message-boards messages
2245            * @param end the upper bound of the range of message-boards messages (not inclusive)
2246            * @return the range of matching message-boards messages
2247            */
2248            public java.util.List<MBMessage> findByT_P(long threadId,
2249                    long parentMessageId, int start, int end);
2250    
2251            /**
2252            * Returns an ordered range of all the message-boards messages where threadId = &#63; and parentMessageId = &#63;.
2253            *
2254            * <p>
2255            * 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 MBMessageModelImpl}. 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.
2256            * </p>
2257            *
2258            * @param threadId the thread ID
2259            * @param parentMessageId the parent message ID
2260            * @param start the lower bound of the range of message-boards messages
2261            * @param end the upper bound of the range of message-boards messages (not inclusive)
2262            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2263            * @return the ordered range of matching message-boards messages
2264            */
2265            public java.util.List<MBMessage> findByT_P(long threadId,
2266                    long parentMessageId, int start, int end,
2267                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
2268    
2269            /**
2270            * Returns an ordered range of all the message-boards messages where threadId = &#63; and parentMessageId = &#63;.
2271            *
2272            * <p>
2273            * 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 MBMessageModelImpl}. 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.
2274            * </p>
2275            *
2276            * @param threadId the thread ID
2277            * @param parentMessageId the parent message ID
2278            * @param start the lower bound of the range of message-boards messages
2279            * @param end the upper bound of the range of message-boards messages (not inclusive)
2280            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2281            * @param retrieveFromCache whether to retrieve from the finder cache
2282            * @return the ordered range of matching message-boards messages
2283            */
2284            public java.util.List<MBMessage> findByT_P(long threadId,
2285                    long parentMessageId, int start, int end,
2286                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator,
2287                    boolean retrieveFromCache);
2288    
2289            /**
2290            * Returns the first message-boards message in the ordered set where threadId = &#63; and parentMessageId = &#63;.
2291            *
2292            * @param threadId the thread ID
2293            * @param parentMessageId the parent message ID
2294            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2295            * @return the first matching message-boards message
2296            * @throws NoSuchMessageException if a matching message-boards message could not be found
2297            */
2298            public MBMessage findByT_P_First(long threadId, long parentMessageId,
2299                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
2300                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
2301    
2302            /**
2303            * Returns the first message-boards message in the ordered set where threadId = &#63; and parentMessageId = &#63;.
2304            *
2305            * @param threadId the thread ID
2306            * @param parentMessageId the parent message ID
2307            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2308            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
2309            */
2310            public MBMessage fetchByT_P_First(long threadId, long parentMessageId,
2311                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
2312    
2313            /**
2314            * Returns the last message-boards message in the ordered set where threadId = &#63; and parentMessageId = &#63;.
2315            *
2316            * @param threadId the thread ID
2317            * @param parentMessageId the parent message ID
2318            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2319            * @return the last matching message-boards message
2320            * @throws NoSuchMessageException if a matching message-boards message could not be found
2321            */
2322            public MBMessage findByT_P_Last(long threadId, long parentMessageId,
2323                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
2324                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
2325    
2326            /**
2327            * Returns the last message-boards message in the ordered set where threadId = &#63; and parentMessageId = &#63;.
2328            *
2329            * @param threadId the thread ID
2330            * @param parentMessageId the parent message ID
2331            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2332            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
2333            */
2334            public MBMessage fetchByT_P_Last(long threadId, long parentMessageId,
2335                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
2336    
2337            /**
2338            * Returns the message-boards messages before and after the current message-boards message in the ordered set where threadId = &#63; and parentMessageId = &#63;.
2339            *
2340            * @param messageId the primary key of the current message-boards message
2341            * @param threadId the thread ID
2342            * @param parentMessageId the parent message ID
2343            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2344            * @return the previous, current, and next message-boards message
2345            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
2346            */
2347            public MBMessage[] findByT_P_PrevAndNext(long messageId, long threadId,
2348                    long parentMessageId,
2349                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
2350                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
2351    
2352            /**
2353            * Removes all the message-boards messages where threadId = &#63; and parentMessageId = &#63; from the database.
2354            *
2355            * @param threadId the thread ID
2356            * @param parentMessageId the parent message ID
2357            */
2358            public void removeByT_P(long threadId, long parentMessageId);
2359    
2360            /**
2361            * Returns the number of message-boards messages where threadId = &#63; and parentMessageId = &#63;.
2362            *
2363            * @param threadId the thread ID
2364            * @param parentMessageId the parent message ID
2365            * @return the number of matching message-boards messages
2366            */
2367            public int countByT_P(long threadId, long parentMessageId);
2368    
2369            /**
2370            * Returns all the message-boards messages where threadId = &#63; and answer = &#63;.
2371            *
2372            * @param threadId the thread ID
2373            * @param answer the answer
2374            * @return the matching message-boards messages
2375            */
2376            public java.util.List<MBMessage> findByT_A(long threadId, boolean answer);
2377    
2378            /**
2379            * Returns a range of all the message-boards messages where threadId = &#63; and answer = &#63;.
2380            *
2381            * <p>
2382            * 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 MBMessageModelImpl}. 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.
2383            * </p>
2384            *
2385            * @param threadId the thread ID
2386            * @param answer the answer
2387            * @param start the lower bound of the range of message-boards messages
2388            * @param end the upper bound of the range of message-boards messages (not inclusive)
2389            * @return the range of matching message-boards messages
2390            */
2391            public java.util.List<MBMessage> findByT_A(long threadId, boolean answer,
2392                    int start, int end);
2393    
2394            /**
2395            * Returns an ordered range of all the message-boards messages where threadId = &#63; and answer = &#63;.
2396            *
2397            * <p>
2398            * 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 MBMessageModelImpl}. 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.
2399            * </p>
2400            *
2401            * @param threadId the thread ID
2402            * @param answer the answer
2403            * @param start the lower bound of the range of message-boards messages
2404            * @param end the upper bound of the range of message-boards messages (not inclusive)
2405            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2406            * @return the ordered range of matching message-boards messages
2407            */
2408            public java.util.List<MBMessage> findByT_A(long threadId, boolean answer,
2409                    int start, int end,
2410                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
2411    
2412            /**
2413            * Returns an ordered range of all the message-boards messages where threadId = &#63; and answer = &#63;.
2414            *
2415            * <p>
2416            * 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 MBMessageModelImpl}. 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.
2417            * </p>
2418            *
2419            * @param threadId the thread ID
2420            * @param answer the answer
2421            * @param start the lower bound of the range of message-boards messages
2422            * @param end the upper bound of the range of message-boards messages (not inclusive)
2423            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2424            * @param retrieveFromCache whether to retrieve from the finder cache
2425            * @return the ordered range of matching message-boards messages
2426            */
2427            public java.util.List<MBMessage> findByT_A(long threadId, boolean answer,
2428                    int start, int end,
2429                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator,
2430                    boolean retrieveFromCache);
2431    
2432            /**
2433            * Returns the first message-boards message in the ordered set where threadId = &#63; and answer = &#63;.
2434            *
2435            * @param threadId the thread ID
2436            * @param answer the answer
2437            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2438            * @return the first matching message-boards message
2439            * @throws NoSuchMessageException if a matching message-boards message could not be found
2440            */
2441            public MBMessage findByT_A_First(long threadId, boolean answer,
2442                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
2443                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
2444    
2445            /**
2446            * Returns the first message-boards message in the ordered set where threadId = &#63; and answer = &#63;.
2447            *
2448            * @param threadId the thread ID
2449            * @param answer the answer
2450            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2451            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
2452            */
2453            public MBMessage fetchByT_A_First(long threadId, boolean answer,
2454                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
2455    
2456            /**
2457            * Returns the last message-boards message in the ordered set where threadId = &#63; and answer = &#63;.
2458            *
2459            * @param threadId the thread ID
2460            * @param answer the answer
2461            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2462            * @return the last matching message-boards message
2463            * @throws NoSuchMessageException if a matching message-boards message could not be found
2464            */
2465            public MBMessage findByT_A_Last(long threadId, boolean answer,
2466                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
2467                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
2468    
2469            /**
2470            * Returns the last message-boards message in the ordered set where threadId = &#63; and answer = &#63;.
2471            *
2472            * @param threadId the thread ID
2473            * @param answer the answer
2474            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2475            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
2476            */
2477            public MBMessage fetchByT_A_Last(long threadId, boolean answer,
2478                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
2479    
2480            /**
2481            * Returns the message-boards messages before and after the current message-boards message in the ordered set where threadId = &#63; and answer = &#63;.
2482            *
2483            * @param messageId the primary key of the current message-boards message
2484            * @param threadId the thread ID
2485            * @param answer the answer
2486            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2487            * @return the previous, current, and next message-boards message
2488            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
2489            */
2490            public MBMessage[] findByT_A_PrevAndNext(long messageId, long threadId,
2491                    boolean answer,
2492                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
2493                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
2494    
2495            /**
2496            * Removes all the message-boards messages where threadId = &#63; and answer = &#63; from the database.
2497            *
2498            * @param threadId the thread ID
2499            * @param answer the answer
2500            */
2501            public void removeByT_A(long threadId, boolean answer);
2502    
2503            /**
2504            * Returns the number of message-boards messages where threadId = &#63; and answer = &#63;.
2505            *
2506            * @param threadId the thread ID
2507            * @param answer the answer
2508            * @return the number of matching message-boards messages
2509            */
2510            public int countByT_A(long threadId, boolean answer);
2511    
2512            /**
2513            * Returns all the message-boards messages where threadId = &#63; and status = &#63;.
2514            *
2515            * @param threadId the thread ID
2516            * @param status the status
2517            * @return the matching message-boards messages
2518            */
2519            public java.util.List<MBMessage> findByT_S(long threadId, int status);
2520    
2521            /**
2522            * Returns a range of all the message-boards messages where threadId = &#63; and status = &#63;.
2523            *
2524            * <p>
2525            * 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 MBMessageModelImpl}. 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.
2526            * </p>
2527            *
2528            * @param threadId the thread ID
2529            * @param status the status
2530            * @param start the lower bound of the range of message-boards messages
2531            * @param end the upper bound of the range of message-boards messages (not inclusive)
2532            * @return the range of matching message-boards messages
2533            */
2534            public java.util.List<MBMessage> findByT_S(long threadId, int status,
2535                    int start, int end);
2536    
2537            /**
2538            * Returns an ordered range of all the message-boards messages where threadId = &#63; and status = &#63;.
2539            *
2540            * <p>
2541            * 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 MBMessageModelImpl}. 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.
2542            * </p>
2543            *
2544            * @param threadId the thread ID
2545            * @param status the status
2546            * @param start the lower bound of the range of message-boards messages
2547            * @param end the upper bound of the range of message-boards messages (not inclusive)
2548            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2549            * @return the ordered range of matching message-boards messages
2550            */
2551            public java.util.List<MBMessage> findByT_S(long threadId, int status,
2552                    int start, int end,
2553                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
2554    
2555            /**
2556            * Returns an ordered range of all the message-boards messages where threadId = &#63; and status = &#63;.
2557            *
2558            * <p>
2559            * 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 MBMessageModelImpl}. 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.
2560            * </p>
2561            *
2562            * @param threadId the thread ID
2563            * @param status the status
2564            * @param start the lower bound of the range of message-boards messages
2565            * @param end the upper bound of the range of message-boards messages (not inclusive)
2566            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2567            * @param retrieveFromCache whether to retrieve from the finder cache
2568            * @return the ordered range of matching message-boards messages
2569            */
2570            public java.util.List<MBMessage> findByT_S(long threadId, int status,
2571                    int start, int end,
2572                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator,
2573                    boolean retrieveFromCache);
2574    
2575            /**
2576            * Returns the first message-boards message in the ordered set where threadId = &#63; and status = &#63;.
2577            *
2578            * @param threadId the thread ID
2579            * @param status the status
2580            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2581            * @return the first matching message-boards message
2582            * @throws NoSuchMessageException if a matching message-boards message could not be found
2583            */
2584            public MBMessage findByT_S_First(long threadId, int status,
2585                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
2586                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
2587    
2588            /**
2589            * Returns the first message-boards message in the ordered set where threadId = &#63; and status = &#63;.
2590            *
2591            * @param threadId the thread ID
2592            * @param status the status
2593            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2594            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
2595            */
2596            public MBMessage fetchByT_S_First(long threadId, int status,
2597                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
2598    
2599            /**
2600            * Returns the last message-boards message in the ordered set where threadId = &#63; and status = &#63;.
2601            *
2602            * @param threadId the thread ID
2603            * @param status the status
2604            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2605            * @return the last matching message-boards message
2606            * @throws NoSuchMessageException if a matching message-boards message could not be found
2607            */
2608            public MBMessage findByT_S_Last(long threadId, int status,
2609                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
2610                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
2611    
2612            /**
2613            * Returns the last message-boards message in the ordered set where threadId = &#63; and status = &#63;.
2614            *
2615            * @param threadId the thread ID
2616            * @param status the status
2617            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2618            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
2619            */
2620            public MBMessage fetchByT_S_Last(long threadId, int status,
2621                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
2622    
2623            /**
2624            * Returns the message-boards messages before and after the current message-boards message in the ordered set where threadId = &#63; and status = &#63;.
2625            *
2626            * @param messageId the primary key of the current message-boards message
2627            * @param threadId the thread ID
2628            * @param status the status
2629            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2630            * @return the previous, current, and next message-boards message
2631            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
2632            */
2633            public MBMessage[] findByT_S_PrevAndNext(long messageId, long threadId,
2634                    int status,
2635                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
2636                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
2637    
2638            /**
2639            * Removes all the message-boards messages where threadId = &#63; and status = &#63; from the database.
2640            *
2641            * @param threadId the thread ID
2642            * @param status the status
2643            */
2644            public void removeByT_S(long threadId, int status);
2645    
2646            /**
2647            * Returns the number of message-boards messages where threadId = &#63; and status = &#63;.
2648            *
2649            * @param threadId the thread ID
2650            * @param status the status
2651            * @return the number of matching message-boards messages
2652            */
2653            public int countByT_S(long threadId, int status);
2654    
2655            /**
2656            * Returns all the message-boards messages where threadId = &#63; and status = &#63;.
2657            *
2658            * @param threadId the thread ID
2659            * @param status the status
2660            * @return the matching message-boards messages
2661            */
2662            public java.util.List<MBMessage> findByTR_S(long threadId, int status);
2663    
2664            /**
2665            * Returns a range of all the message-boards messages where threadId = &#63; and status = &#63;.
2666            *
2667            * <p>
2668            * 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 MBMessageModelImpl}. 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.
2669            * </p>
2670            *
2671            * @param threadId the thread ID
2672            * @param status the status
2673            * @param start the lower bound of the range of message-boards messages
2674            * @param end the upper bound of the range of message-boards messages (not inclusive)
2675            * @return the range of matching message-boards messages
2676            */
2677            public java.util.List<MBMessage> findByTR_S(long threadId, int status,
2678                    int start, int end);
2679    
2680            /**
2681            * Returns an ordered range of all the message-boards messages where threadId = &#63; and status = &#63;.
2682            *
2683            * <p>
2684            * 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 MBMessageModelImpl}. 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.
2685            * </p>
2686            *
2687            * @param threadId the thread ID
2688            * @param status the status
2689            * @param start the lower bound of the range of message-boards messages
2690            * @param end the upper bound of the range of message-boards messages (not inclusive)
2691            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2692            * @return the ordered range of matching message-boards messages
2693            */
2694            public java.util.List<MBMessage> findByTR_S(long threadId, int status,
2695                    int start, int end,
2696                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
2697    
2698            /**
2699            * Returns an ordered range of all the message-boards messages where threadId = &#63; and status = &#63;.
2700            *
2701            * <p>
2702            * 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 MBMessageModelImpl}. 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.
2703            * </p>
2704            *
2705            * @param threadId the thread ID
2706            * @param status the status
2707            * @param start the lower bound of the range of message-boards messages
2708            * @param end the upper bound of the range of message-boards messages (not inclusive)
2709            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2710            * @param retrieveFromCache whether to retrieve from the finder cache
2711            * @return the ordered range of matching message-boards messages
2712            */
2713            public java.util.List<MBMessage> findByTR_S(long threadId, int status,
2714                    int start, int end,
2715                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator,
2716                    boolean retrieveFromCache);
2717    
2718            /**
2719            * Returns the first message-boards message in the ordered set where threadId = &#63; and status = &#63;.
2720            *
2721            * @param threadId the thread ID
2722            * @param status the status
2723            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2724            * @return the first matching message-boards message
2725            * @throws NoSuchMessageException if a matching message-boards message could not be found
2726            */
2727            public MBMessage findByTR_S_First(long threadId, int status,
2728                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
2729                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
2730    
2731            /**
2732            * Returns the first message-boards message in the ordered set where threadId = &#63; and status = &#63;.
2733            *
2734            * @param threadId the thread ID
2735            * @param status the status
2736            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2737            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
2738            */
2739            public MBMessage fetchByTR_S_First(long threadId, int status,
2740                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
2741    
2742            /**
2743            * Returns the last message-boards message in the ordered set where threadId = &#63; and status = &#63;.
2744            *
2745            * @param threadId the thread ID
2746            * @param status the status
2747            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2748            * @return the last matching message-boards message
2749            * @throws NoSuchMessageException if a matching message-boards message could not be found
2750            */
2751            public MBMessage findByTR_S_Last(long threadId, int status,
2752                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
2753                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
2754    
2755            /**
2756            * Returns the last message-boards message in the ordered set where threadId = &#63; and status = &#63;.
2757            *
2758            * @param threadId the thread ID
2759            * @param status the status
2760            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2761            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
2762            */
2763            public MBMessage fetchByTR_S_Last(long threadId, int status,
2764                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
2765    
2766            /**
2767            * Returns the message-boards messages before and after the current message-boards message in the ordered set where threadId = &#63; and status = &#63;.
2768            *
2769            * @param messageId the primary key of the current message-boards message
2770            * @param threadId the thread ID
2771            * @param status the status
2772            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2773            * @return the previous, current, and next message-boards message
2774            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
2775            */
2776            public MBMessage[] findByTR_S_PrevAndNext(long messageId, long threadId,
2777                    int status,
2778                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
2779                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
2780    
2781            /**
2782            * Removes all the message-boards messages where threadId = &#63; and status = &#63; from the database.
2783            *
2784            * @param threadId the thread ID
2785            * @param status the status
2786            */
2787            public void removeByTR_S(long threadId, int status);
2788    
2789            /**
2790            * Returns the number of message-boards messages where threadId = &#63; and status = &#63;.
2791            *
2792            * @param threadId the thread ID
2793            * @param status the status
2794            * @return the number of matching message-boards messages
2795            */
2796            public int countByTR_S(long threadId, int status);
2797    
2798            /**
2799            * Returns all the message-boards messages where groupId = &#63; and userId = &#63; and status = &#63;.
2800            *
2801            * @param groupId the group ID
2802            * @param userId the user ID
2803            * @param status the status
2804            * @return the matching message-boards messages
2805            */
2806            public java.util.List<MBMessage> findByG_U_S(long groupId, long userId,
2807                    int status);
2808    
2809            /**
2810            * Returns a range of all the message-boards messages where groupId = &#63; and userId = &#63; and status = &#63;.
2811            *
2812            * <p>
2813            * 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 MBMessageModelImpl}. 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.
2814            * </p>
2815            *
2816            * @param groupId the group ID
2817            * @param userId the user ID
2818            * @param status the status
2819            * @param start the lower bound of the range of message-boards messages
2820            * @param end the upper bound of the range of message-boards messages (not inclusive)
2821            * @return the range of matching message-boards messages
2822            */
2823            public java.util.List<MBMessage> findByG_U_S(long groupId, long userId,
2824                    int status, int start, int end);
2825    
2826            /**
2827            * Returns an ordered range of all the message-boards messages where groupId = &#63; and userId = &#63; and status = &#63;.
2828            *
2829            * <p>
2830            * 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 MBMessageModelImpl}. 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.
2831            * </p>
2832            *
2833            * @param groupId the group ID
2834            * @param userId the user ID
2835            * @param status the status
2836            * @param start the lower bound of the range of message-boards messages
2837            * @param end the upper bound of the range of message-boards messages (not inclusive)
2838            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2839            * @return the ordered range of matching message-boards messages
2840            */
2841            public java.util.List<MBMessage> findByG_U_S(long groupId, long userId,
2842                    int status, int start, int end,
2843                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
2844    
2845            /**
2846            * Returns an ordered range of all the message-boards messages where groupId = &#63; and userId = &#63; and status = &#63;.
2847            *
2848            * <p>
2849            * 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 MBMessageModelImpl}. 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.
2850            * </p>
2851            *
2852            * @param groupId the group ID
2853            * @param userId the user ID
2854            * @param status the status
2855            * @param start the lower bound of the range of message-boards messages
2856            * @param end the upper bound of the range of message-boards messages (not inclusive)
2857            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2858            * @param retrieveFromCache whether to retrieve from the finder cache
2859            * @return the ordered range of matching message-boards messages
2860            */
2861            public java.util.List<MBMessage> findByG_U_S(long groupId, long userId,
2862                    int status, int start, int end,
2863                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator,
2864                    boolean retrieveFromCache);
2865    
2866            /**
2867            * Returns the first message-boards message in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
2868            *
2869            * @param groupId the group ID
2870            * @param userId the user ID
2871            * @param status the status
2872            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2873            * @return the first matching message-boards message
2874            * @throws NoSuchMessageException if a matching message-boards message could not be found
2875            */
2876            public MBMessage findByG_U_S_First(long groupId, long userId, int status,
2877                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
2878                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
2879    
2880            /**
2881            * Returns the first message-boards message in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
2882            *
2883            * @param groupId the group ID
2884            * @param userId the user ID
2885            * @param status the status
2886            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2887            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
2888            */
2889            public MBMessage fetchByG_U_S_First(long groupId, long userId, int status,
2890                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
2891    
2892            /**
2893            * Returns the last message-boards message in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
2894            *
2895            * @param groupId the group ID
2896            * @param userId the user ID
2897            * @param status the status
2898            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2899            * @return the last matching message-boards message
2900            * @throws NoSuchMessageException if a matching message-boards message could not be found
2901            */
2902            public MBMessage findByG_U_S_Last(long groupId, long userId, int status,
2903                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
2904                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
2905    
2906            /**
2907            * Returns the last message-boards message in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
2908            *
2909            * @param groupId the group ID
2910            * @param userId the user ID
2911            * @param status the status
2912            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2913            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
2914            */
2915            public MBMessage fetchByG_U_S_Last(long groupId, long userId, int status,
2916                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
2917    
2918            /**
2919            * Returns the message-boards messages before and after the current message-boards message in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
2920            *
2921            * @param messageId the primary key of the current message-boards message
2922            * @param groupId the group ID
2923            * @param userId the user ID
2924            * @param status the status
2925            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2926            * @return the previous, current, and next message-boards message
2927            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
2928            */
2929            public MBMessage[] findByG_U_S_PrevAndNext(long messageId, long groupId,
2930                    long userId, int status,
2931                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
2932                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
2933    
2934            /**
2935            * Returns all the message-boards messages that the user has permission to view where groupId = &#63; and userId = &#63; and status = &#63;.
2936            *
2937            * @param groupId the group ID
2938            * @param userId the user ID
2939            * @param status the status
2940            * @return the matching message-boards messages that the user has permission to view
2941            */
2942            public java.util.List<MBMessage> filterFindByG_U_S(long groupId,
2943                    long userId, int status);
2944    
2945            /**
2946            * Returns a range of all the message-boards messages that the user has permission to view where groupId = &#63; and userId = &#63; and status = &#63;.
2947            *
2948            * <p>
2949            * 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 MBMessageModelImpl}. 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.
2950            * </p>
2951            *
2952            * @param groupId the group ID
2953            * @param userId the user ID
2954            * @param status the status
2955            * @param start the lower bound of the range of message-boards messages
2956            * @param end the upper bound of the range of message-boards messages (not inclusive)
2957            * @return the range of matching message-boards messages that the user has permission to view
2958            */
2959            public java.util.List<MBMessage> filterFindByG_U_S(long groupId,
2960                    long userId, int status, int start, int end);
2961    
2962            /**
2963            * Returns an ordered range of all the message-boards messages that the user has permissions to view where groupId = &#63; and userId = &#63; and status = &#63;.
2964            *
2965            * <p>
2966            * 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 MBMessageModelImpl}. 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.
2967            * </p>
2968            *
2969            * @param groupId the group ID
2970            * @param userId the user ID
2971            * @param status the status
2972            * @param start the lower bound of the range of message-boards messages
2973            * @param end the upper bound of the range of message-boards messages (not inclusive)
2974            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2975            * @return the ordered range of matching message-boards messages that the user has permission to view
2976            */
2977            public java.util.List<MBMessage> filterFindByG_U_S(long groupId,
2978                    long userId, int status, int start, int end,
2979                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
2980    
2981            /**
2982            * Returns the message-boards messages before and after the current message-boards message in the ordered set of message-boards messages that the user has permission to view where groupId = &#63; and userId = &#63; and status = &#63;.
2983            *
2984            * @param messageId the primary key of the current message-boards message
2985            * @param groupId the group ID
2986            * @param userId the user ID
2987            * @param status the status
2988            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2989            * @return the previous, current, and next message-boards message
2990            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
2991            */
2992            public MBMessage[] filterFindByG_U_S_PrevAndNext(long messageId,
2993                    long groupId, long userId, int status,
2994                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
2995                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
2996    
2997            /**
2998            * Removes all the message-boards messages where groupId = &#63; and userId = &#63; and status = &#63; from the database.
2999            *
3000            * @param groupId the group ID
3001            * @param userId the user ID
3002            * @param status the status
3003            */
3004            public void removeByG_U_S(long groupId, long userId, int status);
3005    
3006            /**
3007            * Returns the number of message-boards messages where groupId = &#63; and userId = &#63; and status = &#63;.
3008            *
3009            * @param groupId the group ID
3010            * @param userId the user ID
3011            * @param status the status
3012            * @return the number of matching message-boards messages
3013            */
3014            public int countByG_U_S(long groupId, long userId, int status);
3015    
3016            /**
3017            * Returns the number of message-boards messages that the user has permission to view where groupId = &#63; and userId = &#63; and status = &#63;.
3018            *
3019            * @param groupId the group ID
3020            * @param userId the user ID
3021            * @param status the status
3022            * @return the number of matching message-boards messages that the user has permission to view
3023            */
3024            public int filterCountByG_U_S(long groupId, long userId, int status);
3025    
3026            /**
3027            * Returns all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
3028            *
3029            * @param groupId the group ID
3030            * @param categoryId the category ID
3031            * @param threadId the thread ID
3032            * @return the matching message-boards messages
3033            */
3034            public java.util.List<MBMessage> findByG_C_T(long groupId, long categoryId,
3035                    long threadId);
3036    
3037            /**
3038            * Returns a range of all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
3039            *
3040            * <p>
3041            * 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 MBMessageModelImpl}. 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.
3042            * </p>
3043            *
3044            * @param groupId the group ID
3045            * @param categoryId the category ID
3046            * @param threadId the thread ID
3047            * @param start the lower bound of the range of message-boards messages
3048            * @param end the upper bound of the range of message-boards messages (not inclusive)
3049            * @return the range of matching message-boards messages
3050            */
3051            public java.util.List<MBMessage> findByG_C_T(long groupId, long categoryId,
3052                    long threadId, int start, int end);
3053    
3054            /**
3055            * Returns an ordered range of all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
3056            *
3057            * <p>
3058            * 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 MBMessageModelImpl}. 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.
3059            * </p>
3060            *
3061            * @param groupId the group ID
3062            * @param categoryId the category ID
3063            * @param threadId the thread ID
3064            * @param start the lower bound of the range of message-boards messages
3065            * @param end the upper bound of the range of message-boards messages (not inclusive)
3066            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3067            * @return the ordered range of matching message-boards messages
3068            */
3069            public java.util.List<MBMessage> findByG_C_T(long groupId, long categoryId,
3070                    long threadId, int start, int end,
3071                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
3072    
3073            /**
3074            * Returns an ordered range of all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
3075            *
3076            * <p>
3077            * 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 MBMessageModelImpl}. 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.
3078            * </p>
3079            *
3080            * @param groupId the group ID
3081            * @param categoryId the category ID
3082            * @param threadId the thread ID
3083            * @param start the lower bound of the range of message-boards messages
3084            * @param end the upper bound of the range of message-boards messages (not inclusive)
3085            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3086            * @param retrieveFromCache whether to retrieve from the finder cache
3087            * @return the ordered range of matching message-boards messages
3088            */
3089            public java.util.List<MBMessage> findByG_C_T(long groupId, long categoryId,
3090                    long threadId, int start, int end,
3091                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator,
3092                    boolean retrieveFromCache);
3093    
3094            /**
3095            * Returns the first message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
3096            *
3097            * @param groupId the group ID
3098            * @param categoryId the category ID
3099            * @param threadId the thread ID
3100            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3101            * @return the first matching message-boards message
3102            * @throws NoSuchMessageException if a matching message-boards message could not be found
3103            */
3104            public MBMessage findByG_C_T_First(long groupId, long categoryId,
3105                    long threadId,
3106                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
3107                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
3108    
3109            /**
3110            * Returns the first message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
3111            *
3112            * @param groupId the group ID
3113            * @param categoryId the category ID
3114            * @param threadId the thread ID
3115            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3116            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
3117            */
3118            public MBMessage fetchByG_C_T_First(long groupId, long categoryId,
3119                    long threadId,
3120                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
3121    
3122            /**
3123            * Returns the last message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
3124            *
3125            * @param groupId the group ID
3126            * @param categoryId the category ID
3127            * @param threadId the thread ID
3128            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3129            * @return the last matching message-boards message
3130            * @throws NoSuchMessageException if a matching message-boards message could not be found
3131            */
3132            public MBMessage findByG_C_T_Last(long groupId, long categoryId,
3133                    long threadId,
3134                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
3135                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
3136    
3137            /**
3138            * Returns the last message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
3139            *
3140            * @param groupId the group ID
3141            * @param categoryId the category ID
3142            * @param threadId the thread ID
3143            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3144            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
3145            */
3146            public MBMessage fetchByG_C_T_Last(long groupId, long categoryId,
3147                    long threadId,
3148                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
3149    
3150            /**
3151            * Returns the message-boards messages before and after the current message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
3152            *
3153            * @param messageId the primary key of the current message-boards message
3154            * @param groupId the group ID
3155            * @param categoryId the category ID
3156            * @param threadId the thread ID
3157            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3158            * @return the previous, current, and next message-boards message
3159            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
3160            */
3161            public MBMessage[] findByG_C_T_PrevAndNext(long messageId, long groupId,
3162                    long categoryId, long threadId,
3163                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
3164                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
3165    
3166            /**
3167            * Returns all the message-boards messages that the user has permission to view where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
3168            *
3169            * @param groupId the group ID
3170            * @param categoryId the category ID
3171            * @param threadId the thread ID
3172            * @return the matching message-boards messages that the user has permission to view
3173            */
3174            public java.util.List<MBMessage> filterFindByG_C_T(long groupId,
3175                    long categoryId, long threadId);
3176    
3177            /**
3178            * Returns a range of all the message-boards messages that the user has permission to view where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
3179            *
3180            * <p>
3181            * 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 MBMessageModelImpl}. 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.
3182            * </p>
3183            *
3184            * @param groupId the group ID
3185            * @param categoryId the category ID
3186            * @param threadId the thread ID
3187            * @param start the lower bound of the range of message-boards messages
3188            * @param end the upper bound of the range of message-boards messages (not inclusive)
3189            * @return the range of matching message-boards messages that the user has permission to view
3190            */
3191            public java.util.List<MBMessage> filterFindByG_C_T(long groupId,
3192                    long categoryId, long threadId, int start, int end);
3193    
3194            /**
3195            * Returns an ordered range of all the message-boards messages that the user has permissions to view where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
3196            *
3197            * <p>
3198            * 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 MBMessageModelImpl}. 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.
3199            * </p>
3200            *
3201            * @param groupId the group ID
3202            * @param categoryId the category ID
3203            * @param threadId the thread ID
3204            * @param start the lower bound of the range of message-boards messages
3205            * @param end the upper bound of the range of message-boards messages (not inclusive)
3206            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3207            * @return the ordered range of matching message-boards messages that the user has permission to view
3208            */
3209            public java.util.List<MBMessage> filterFindByG_C_T(long groupId,
3210                    long categoryId, long threadId, int start, int end,
3211                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
3212    
3213            /**
3214            * Returns the message-boards messages before and after the current message-boards message in the ordered set of message-boards messages that the user has permission to view where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
3215            *
3216            * @param messageId the primary key of the current message-boards message
3217            * @param groupId the group ID
3218            * @param categoryId the category ID
3219            * @param threadId the thread ID
3220            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3221            * @return the previous, current, and next message-boards message
3222            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
3223            */
3224            public MBMessage[] filterFindByG_C_T_PrevAndNext(long messageId,
3225                    long groupId, long categoryId, long threadId,
3226                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
3227                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
3228    
3229            /**
3230            * Removes all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; from the database.
3231            *
3232            * @param groupId the group ID
3233            * @param categoryId the category ID
3234            * @param threadId the thread ID
3235            */
3236            public void removeByG_C_T(long groupId, long categoryId, long threadId);
3237    
3238            /**
3239            * Returns the number of message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
3240            *
3241            * @param groupId the group ID
3242            * @param categoryId the category ID
3243            * @param threadId the thread ID
3244            * @return the number of matching message-boards messages
3245            */
3246            public int countByG_C_T(long groupId, long categoryId, long threadId);
3247    
3248            /**
3249            * Returns the number of message-boards messages that the user has permission to view where groupId = &#63; and categoryId = &#63; and threadId = &#63;.
3250            *
3251            * @param groupId the group ID
3252            * @param categoryId the category ID
3253            * @param threadId the thread ID
3254            * @return the number of matching message-boards messages that the user has permission to view
3255            */
3256            public int filterCountByG_C_T(long groupId, long categoryId, long threadId);
3257    
3258            /**
3259            * Returns all the message-boards messages where groupId = &#63; and categoryId = &#63; and status = &#63;.
3260            *
3261            * @param groupId the group ID
3262            * @param categoryId the category ID
3263            * @param status the status
3264            * @return the matching message-boards messages
3265            */
3266            public java.util.List<MBMessage> findByG_C_S(long groupId, long categoryId,
3267                    int status);
3268    
3269            /**
3270            * Returns a range of all the message-boards messages where groupId = &#63; and categoryId = &#63; and status = &#63;.
3271            *
3272            * <p>
3273            * 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 MBMessageModelImpl}. 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.
3274            * </p>
3275            *
3276            * @param groupId the group ID
3277            * @param categoryId the category ID
3278            * @param status the status
3279            * @param start the lower bound of the range of message-boards messages
3280            * @param end the upper bound of the range of message-boards messages (not inclusive)
3281            * @return the range of matching message-boards messages
3282            */
3283            public java.util.List<MBMessage> findByG_C_S(long groupId, long categoryId,
3284                    int status, int start, int end);
3285    
3286            /**
3287            * Returns an ordered range of all the message-boards messages where groupId = &#63; and categoryId = &#63; and status = &#63;.
3288            *
3289            * <p>
3290            * 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 MBMessageModelImpl}. 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.
3291            * </p>
3292            *
3293            * @param groupId the group ID
3294            * @param categoryId the category ID
3295            * @param status the status
3296            * @param start the lower bound of the range of message-boards messages
3297            * @param end the upper bound of the range of message-boards messages (not inclusive)
3298            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3299            * @return the ordered range of matching message-boards messages
3300            */
3301            public java.util.List<MBMessage> findByG_C_S(long groupId, long categoryId,
3302                    int status, int start, int end,
3303                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
3304    
3305            /**
3306            * Returns an ordered range of all the message-boards messages where groupId = &#63; and categoryId = &#63; and status = &#63;.
3307            *
3308            * <p>
3309            * 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 MBMessageModelImpl}. 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.
3310            * </p>
3311            *
3312            * @param groupId the group ID
3313            * @param categoryId the category ID
3314            * @param status the status
3315            * @param start the lower bound of the range of message-boards messages
3316            * @param end the upper bound of the range of message-boards messages (not inclusive)
3317            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3318            * @param retrieveFromCache whether to retrieve from the finder cache
3319            * @return the ordered range of matching message-boards messages
3320            */
3321            public java.util.List<MBMessage> findByG_C_S(long groupId, long categoryId,
3322                    int status, int start, int end,
3323                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator,
3324                    boolean retrieveFromCache);
3325    
3326            /**
3327            * Returns the first message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and status = &#63;.
3328            *
3329            * @param groupId the group ID
3330            * @param categoryId the category ID
3331            * @param status the status
3332            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3333            * @return the first matching message-boards message
3334            * @throws NoSuchMessageException if a matching message-boards message could not be found
3335            */
3336            public MBMessage findByG_C_S_First(long groupId, long categoryId,
3337                    int status,
3338                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
3339                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
3340    
3341            /**
3342            * Returns the first message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and status = &#63;.
3343            *
3344            * @param groupId the group ID
3345            * @param categoryId the category ID
3346            * @param status the status
3347            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3348            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
3349            */
3350            public MBMessage fetchByG_C_S_First(long groupId, long categoryId,
3351                    int status,
3352                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
3353    
3354            /**
3355            * Returns the last message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and status = &#63;.
3356            *
3357            * @param groupId the group ID
3358            * @param categoryId the category ID
3359            * @param status the status
3360            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3361            * @return the last matching message-boards message
3362            * @throws NoSuchMessageException if a matching message-boards message could not be found
3363            */
3364            public MBMessage findByG_C_S_Last(long groupId, long categoryId,
3365                    int status,
3366                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
3367                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
3368    
3369            /**
3370            * Returns the last message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and status = &#63;.
3371            *
3372            * @param groupId the group ID
3373            * @param categoryId the category ID
3374            * @param status the status
3375            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3376            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
3377            */
3378            public MBMessage fetchByG_C_S_Last(long groupId, long categoryId,
3379                    int status,
3380                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
3381    
3382            /**
3383            * Returns the message-boards messages before and after the current message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and status = &#63;.
3384            *
3385            * @param messageId the primary key of the current message-boards message
3386            * @param groupId the group ID
3387            * @param categoryId the category ID
3388            * @param status the status
3389            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3390            * @return the previous, current, and next message-boards message
3391            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
3392            */
3393            public MBMessage[] findByG_C_S_PrevAndNext(long messageId, long groupId,
3394                    long categoryId, int status,
3395                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
3396                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
3397    
3398            /**
3399            * Returns all the message-boards messages that the user has permission to view where groupId = &#63; and categoryId = &#63; and status = &#63;.
3400            *
3401            * @param groupId the group ID
3402            * @param categoryId the category ID
3403            * @param status the status
3404            * @return the matching message-boards messages that the user has permission to view
3405            */
3406            public java.util.List<MBMessage> filterFindByG_C_S(long groupId,
3407                    long categoryId, int status);
3408    
3409            /**
3410            * Returns a range of all the message-boards messages that the user has permission to view where groupId = &#63; and categoryId = &#63; and status = &#63;.
3411            *
3412            * <p>
3413            * 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 MBMessageModelImpl}. 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.
3414            * </p>
3415            *
3416            * @param groupId the group ID
3417            * @param categoryId the category ID
3418            * @param status the status
3419            * @param start the lower bound of the range of message-boards messages
3420            * @param end the upper bound of the range of message-boards messages (not inclusive)
3421            * @return the range of matching message-boards messages that the user has permission to view
3422            */
3423            public java.util.List<MBMessage> filterFindByG_C_S(long groupId,
3424                    long categoryId, int status, int start, int end);
3425    
3426            /**
3427            * Returns an ordered range of all the message-boards messages that the user has permissions to view where groupId = &#63; and categoryId = &#63; and status = &#63;.
3428            *
3429            * <p>
3430            * 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 MBMessageModelImpl}. 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.
3431            * </p>
3432            *
3433            * @param groupId the group ID
3434            * @param categoryId the category ID
3435            * @param status the status
3436            * @param start the lower bound of the range of message-boards messages
3437            * @param end the upper bound of the range of message-boards messages (not inclusive)
3438            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3439            * @return the ordered range of matching message-boards messages that the user has permission to view
3440            */
3441            public java.util.List<MBMessage> filterFindByG_C_S(long groupId,
3442                    long categoryId, int status, int start, int end,
3443                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
3444    
3445            /**
3446            * Returns the message-boards messages before and after the current message-boards message in the ordered set of message-boards messages that the user has permission to view where groupId = &#63; and categoryId = &#63; and status = &#63;.
3447            *
3448            * @param messageId the primary key of the current message-boards message
3449            * @param groupId the group ID
3450            * @param categoryId the category ID
3451            * @param status the status
3452            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3453            * @return the previous, current, and next message-boards message
3454            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
3455            */
3456            public MBMessage[] filterFindByG_C_S_PrevAndNext(long messageId,
3457                    long groupId, long categoryId, int status,
3458                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
3459                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
3460    
3461            /**
3462            * Removes all the message-boards messages where groupId = &#63; and categoryId = &#63; and status = &#63; from the database.
3463            *
3464            * @param groupId the group ID
3465            * @param categoryId the category ID
3466            * @param status the status
3467            */
3468            public void removeByG_C_S(long groupId, long categoryId, int status);
3469    
3470            /**
3471            * Returns the number of message-boards messages where groupId = &#63; and categoryId = &#63; and status = &#63;.
3472            *
3473            * @param groupId the group ID
3474            * @param categoryId the category ID
3475            * @param status the status
3476            * @return the number of matching message-boards messages
3477            */
3478            public int countByG_C_S(long groupId, long categoryId, int status);
3479    
3480            /**
3481            * Returns the number of message-boards messages that the user has permission to view where groupId = &#63; and categoryId = &#63; and status = &#63;.
3482            *
3483            * @param groupId the group ID
3484            * @param categoryId the category ID
3485            * @param status the status
3486            * @return the number of matching message-boards messages that the user has permission to view
3487            */
3488            public int filterCountByG_C_S(long groupId, long categoryId, int status);
3489    
3490            /**
3491            * Returns all the message-boards messages where userId = &#63; and classNameId = &#63; and classPK = &#63;.
3492            *
3493            * @param userId the user ID
3494            * @param classNameId the class name ID
3495            * @param classPK the class p k
3496            * @return the matching message-boards messages
3497            */
3498            public java.util.List<MBMessage> findByU_C_C(long userId, long classNameId,
3499                    long classPK);
3500    
3501            /**
3502            * Returns a range of all the message-boards messages where userId = &#63; and classNameId = &#63; and classPK = &#63;.
3503            *
3504            * <p>
3505            * 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 MBMessageModelImpl}. 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.
3506            * </p>
3507            *
3508            * @param userId the user ID
3509            * @param classNameId the class name ID
3510            * @param classPK the class p k
3511            * @param start the lower bound of the range of message-boards messages
3512            * @param end the upper bound of the range of message-boards messages (not inclusive)
3513            * @return the range of matching message-boards messages
3514            */
3515            public java.util.List<MBMessage> findByU_C_C(long userId, long classNameId,
3516                    long classPK, int start, int end);
3517    
3518            /**
3519            * Returns an ordered range of all the message-boards messages where userId = &#63; and classNameId = &#63; and classPK = &#63;.
3520            *
3521            * <p>
3522            * 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 MBMessageModelImpl}. 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.
3523            * </p>
3524            *
3525            * @param userId the user ID
3526            * @param classNameId the class name ID
3527            * @param classPK the class p k
3528            * @param start the lower bound of the range of message-boards messages
3529            * @param end the upper bound of the range of message-boards messages (not inclusive)
3530            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3531            * @return the ordered range of matching message-boards messages
3532            */
3533            public java.util.List<MBMessage> findByU_C_C(long userId, long classNameId,
3534                    long classPK, int start, int end,
3535                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
3536    
3537            /**
3538            * Returns an ordered range of all the message-boards messages where userId = &#63; and classNameId = &#63; and classPK = &#63;.
3539            *
3540            * <p>
3541            * 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 MBMessageModelImpl}. 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.
3542            * </p>
3543            *
3544            * @param userId the user ID
3545            * @param classNameId the class name ID
3546            * @param classPK the class p k
3547            * @param start the lower bound of the range of message-boards messages
3548            * @param end the upper bound of the range of message-boards messages (not inclusive)
3549            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3550            * @param retrieveFromCache whether to retrieve from the finder cache
3551            * @return the ordered range of matching message-boards messages
3552            */
3553            public java.util.List<MBMessage> findByU_C_C(long userId, long classNameId,
3554                    long classPK, int start, int end,
3555                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator,
3556                    boolean retrieveFromCache);
3557    
3558            /**
3559            * Returns the first message-boards message in the ordered set where userId = &#63; and classNameId = &#63; and classPK = &#63;.
3560            *
3561            * @param userId the user ID
3562            * @param classNameId the class name ID
3563            * @param classPK the class p k
3564            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3565            * @return the first matching message-boards message
3566            * @throws NoSuchMessageException if a matching message-boards message could not be found
3567            */
3568            public MBMessage findByU_C_C_First(long userId, long classNameId,
3569                    long classPK,
3570                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
3571                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
3572    
3573            /**
3574            * Returns the first message-boards message in the ordered set where userId = &#63; and classNameId = &#63; and classPK = &#63;.
3575            *
3576            * @param userId the user ID
3577            * @param classNameId the class name ID
3578            * @param classPK the class p k
3579            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3580            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
3581            */
3582            public MBMessage fetchByU_C_C_First(long userId, long classNameId,
3583                    long classPK,
3584                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
3585    
3586            /**
3587            * Returns the last message-boards message in the ordered set where userId = &#63; and classNameId = &#63; and classPK = &#63;.
3588            *
3589            * @param userId the user ID
3590            * @param classNameId the class name ID
3591            * @param classPK the class p k
3592            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3593            * @return the last matching message-boards message
3594            * @throws NoSuchMessageException if a matching message-boards message could not be found
3595            */
3596            public MBMessage findByU_C_C_Last(long userId, long classNameId,
3597                    long classPK,
3598                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
3599                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
3600    
3601            /**
3602            * Returns the last message-boards message in the ordered set where userId = &#63; and classNameId = &#63; and classPK = &#63;.
3603            *
3604            * @param userId the user ID
3605            * @param classNameId the class name ID
3606            * @param classPK the class p k
3607            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3608            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
3609            */
3610            public MBMessage fetchByU_C_C_Last(long userId, long classNameId,
3611                    long classPK,
3612                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
3613    
3614            /**
3615            * Returns the message-boards messages before and after the current message-boards message in the ordered set where userId = &#63; and classNameId = &#63; and classPK = &#63;.
3616            *
3617            * @param messageId the primary key of the current message-boards message
3618            * @param userId the user ID
3619            * @param classNameId the class name ID
3620            * @param classPK the class p k
3621            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3622            * @return the previous, current, and next message-boards message
3623            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
3624            */
3625            public MBMessage[] findByU_C_C_PrevAndNext(long messageId, long userId,
3626                    long classNameId, long classPK,
3627                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
3628                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
3629    
3630            /**
3631            * Removes all the message-boards messages where userId = &#63; and classNameId = &#63; and classPK = &#63; from the database.
3632            *
3633            * @param userId the user ID
3634            * @param classNameId the class name ID
3635            * @param classPK the class p k
3636            */
3637            public void removeByU_C_C(long userId, long classNameId, long classPK);
3638    
3639            /**
3640            * Returns the number of message-boards messages where userId = &#63; and classNameId = &#63; and classPK = &#63;.
3641            *
3642            * @param userId the user ID
3643            * @param classNameId the class name ID
3644            * @param classPK the class p k
3645            * @return the number of matching message-boards messages
3646            */
3647            public int countByU_C_C(long userId, long classNameId, long classPK);
3648    
3649            /**
3650            * Returns all the message-boards messages where userId = &#63; and classNameId = &#63; and status = &#63;.
3651            *
3652            * @param userId the user ID
3653            * @param classNameId the class name ID
3654            * @param status the status
3655            * @return the matching message-boards messages
3656            */
3657            public java.util.List<MBMessage> findByU_C_S(long userId, long classNameId,
3658                    int status);
3659    
3660            /**
3661            * Returns a range of all the message-boards messages where userId = &#63; and classNameId = &#63; and status = &#63;.
3662            *
3663            * <p>
3664            * 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 MBMessageModelImpl}. 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.
3665            * </p>
3666            *
3667            * @param userId the user ID
3668            * @param classNameId the class name ID
3669            * @param status the status
3670            * @param start the lower bound of the range of message-boards messages
3671            * @param end the upper bound of the range of message-boards messages (not inclusive)
3672            * @return the range of matching message-boards messages
3673            */
3674            public java.util.List<MBMessage> findByU_C_S(long userId, long classNameId,
3675                    int status, int start, int end);
3676    
3677            /**
3678            * Returns an ordered range of all the message-boards messages where userId = &#63; and classNameId = &#63; and status = &#63;.
3679            *
3680            * <p>
3681            * 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 MBMessageModelImpl}. 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.
3682            * </p>
3683            *
3684            * @param userId the user ID
3685            * @param classNameId the class name ID
3686            * @param status the status
3687            * @param start the lower bound of the range of message-boards messages
3688            * @param end the upper bound of the range of message-boards messages (not inclusive)
3689            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3690            * @return the ordered range of matching message-boards messages
3691            */
3692            public java.util.List<MBMessage> findByU_C_S(long userId, long classNameId,
3693                    int status, int start, int end,
3694                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
3695    
3696            /**
3697            * Returns an ordered range of all the message-boards messages where userId = &#63; and classNameId = &#63; and status = &#63;.
3698            *
3699            * <p>
3700            * 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 MBMessageModelImpl}. 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.
3701            * </p>
3702            *
3703            * @param userId the user ID
3704            * @param classNameId the class name ID
3705            * @param status the status
3706            * @param start the lower bound of the range of message-boards messages
3707            * @param end the upper bound of the range of message-boards messages (not inclusive)
3708            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3709            * @param retrieveFromCache whether to retrieve from the finder cache
3710            * @return the ordered range of matching message-boards messages
3711            */
3712            public java.util.List<MBMessage> findByU_C_S(long userId, long classNameId,
3713                    int status, int start, int end,
3714                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator,
3715                    boolean retrieveFromCache);
3716    
3717            /**
3718            * Returns the first message-boards message in the ordered set where userId = &#63; and classNameId = &#63; and status = &#63;.
3719            *
3720            * @param userId the user ID
3721            * @param classNameId the class name ID
3722            * @param status the status
3723            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3724            * @return the first matching message-boards message
3725            * @throws NoSuchMessageException if a matching message-boards message could not be found
3726            */
3727            public MBMessage findByU_C_S_First(long userId, long classNameId,
3728                    int status,
3729                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
3730                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
3731    
3732            /**
3733            * Returns the first message-boards message in the ordered set where userId = &#63; and classNameId = &#63; and status = &#63;.
3734            *
3735            * @param userId the user ID
3736            * @param classNameId the class name ID
3737            * @param status the status
3738            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3739            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
3740            */
3741            public MBMessage fetchByU_C_S_First(long userId, long classNameId,
3742                    int status,
3743                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
3744    
3745            /**
3746            * Returns the last message-boards message in the ordered set where userId = &#63; and classNameId = &#63; and status = &#63;.
3747            *
3748            * @param userId the user ID
3749            * @param classNameId the class name ID
3750            * @param status the status
3751            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3752            * @return the last matching message-boards message
3753            * @throws NoSuchMessageException if a matching message-boards message could not be found
3754            */
3755            public MBMessage findByU_C_S_Last(long userId, long classNameId,
3756                    int status,
3757                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
3758                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
3759    
3760            /**
3761            * Returns the last message-boards message in the ordered set where userId = &#63; and classNameId = &#63; and status = &#63;.
3762            *
3763            * @param userId the user ID
3764            * @param classNameId the class name ID
3765            * @param status the status
3766            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3767            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
3768            */
3769            public MBMessage fetchByU_C_S_Last(long userId, long classNameId,
3770                    int status,
3771                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
3772    
3773            /**
3774            * Returns the message-boards messages before and after the current message-boards message in the ordered set where userId = &#63; and classNameId = &#63; and status = &#63;.
3775            *
3776            * @param messageId the primary key of the current message-boards message
3777            * @param userId the user ID
3778            * @param classNameId the class name ID
3779            * @param status the status
3780            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3781            * @return the previous, current, and next message-boards message
3782            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
3783            */
3784            public MBMessage[] findByU_C_S_PrevAndNext(long messageId, long userId,
3785                    long classNameId, int status,
3786                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
3787                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
3788    
3789            /**
3790            * Returns all the message-boards messages where userId = &#63; and classNameId = any &#63; and status = &#63;.
3791            *
3792            * <p>
3793            * 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 MBMessageModelImpl}. 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.
3794            * </p>
3795            *
3796            * @param userId the user ID
3797            * @param classNameIds the class name IDs
3798            * @param status the status
3799            * @return the matching message-boards messages
3800            */
3801            public java.util.List<MBMessage> findByU_C_S(long userId,
3802                    long[] classNameIds, int status);
3803    
3804            /**
3805            * Returns a range of all the message-boards messages where userId = &#63; and classNameId = any &#63; and status = &#63;.
3806            *
3807            * <p>
3808            * 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 MBMessageModelImpl}. 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.
3809            * </p>
3810            *
3811            * @param userId the user ID
3812            * @param classNameIds the class name IDs
3813            * @param status the status
3814            * @param start the lower bound of the range of message-boards messages
3815            * @param end the upper bound of the range of message-boards messages (not inclusive)
3816            * @return the range of matching message-boards messages
3817            */
3818            public java.util.List<MBMessage> findByU_C_S(long userId,
3819                    long[] classNameIds, int status, int start, int end);
3820    
3821            /**
3822            * Returns an ordered range of all the message-boards messages where userId = &#63; and classNameId = any &#63; and status = &#63;.
3823            *
3824            * <p>
3825            * 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 MBMessageModelImpl}. 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.
3826            * </p>
3827            *
3828            * @param userId the user ID
3829            * @param classNameIds the class name IDs
3830            * @param status the status
3831            * @param start the lower bound of the range of message-boards messages
3832            * @param end the upper bound of the range of message-boards messages (not inclusive)
3833            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3834            * @return the ordered range of matching message-boards messages
3835            */
3836            public java.util.List<MBMessage> findByU_C_S(long userId,
3837                    long[] classNameIds, int status, int start, int end,
3838                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
3839    
3840            /**
3841            * Returns an ordered range of all the message-boards messages where userId = &#63; and classNameId = &#63; and status = &#63;, optionally using the finder cache.
3842            *
3843            * <p>
3844            * 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 MBMessageModelImpl}. 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.
3845            * </p>
3846            *
3847            * @param userId the user ID
3848            * @param classNameId the class name ID
3849            * @param status the status
3850            * @param start the lower bound of the range of message-boards messages
3851            * @param end the upper bound of the range of message-boards messages (not inclusive)
3852            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3853            * @param retrieveFromCache whether to retrieve from the finder cache
3854            * @return the ordered range of matching message-boards messages
3855            */
3856            public java.util.List<MBMessage> findByU_C_S(long userId,
3857                    long[] classNameIds, int status, int start, int end,
3858                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator,
3859                    boolean retrieveFromCache);
3860    
3861            /**
3862            * Removes all the message-boards messages where userId = &#63; and classNameId = &#63; and status = &#63; from the database.
3863            *
3864            * @param userId the user ID
3865            * @param classNameId the class name ID
3866            * @param status the status
3867            */
3868            public void removeByU_C_S(long userId, long classNameId, int status);
3869    
3870            /**
3871            * Returns the number of message-boards messages where userId = &#63; and classNameId = &#63; and status = &#63;.
3872            *
3873            * @param userId the user ID
3874            * @param classNameId the class name ID
3875            * @param status the status
3876            * @return the number of matching message-boards messages
3877            */
3878            public int countByU_C_S(long userId, long classNameId, int status);
3879    
3880            /**
3881            * Returns the number of message-boards messages where userId = &#63; and classNameId = any &#63; and status = &#63;.
3882            *
3883            * @param userId the user ID
3884            * @param classNameIds the class name IDs
3885            * @param status the status
3886            * @return the number of matching message-boards messages
3887            */
3888            public int countByU_C_S(long userId, long[] classNameIds, int status);
3889    
3890            /**
3891            * Returns all the message-boards messages where classNameId = &#63; and classPK = &#63; and status = &#63;.
3892            *
3893            * @param classNameId the class name ID
3894            * @param classPK the class p k
3895            * @param status the status
3896            * @return the matching message-boards messages
3897            */
3898            public java.util.List<MBMessage> findByC_C_S(long classNameId,
3899                    long classPK, int status);
3900    
3901            /**
3902            * Returns a range of all the message-boards messages where classNameId = &#63; and classPK = &#63; and status = &#63;.
3903            *
3904            * <p>
3905            * 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 MBMessageModelImpl}. 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.
3906            * </p>
3907            *
3908            * @param classNameId the class name ID
3909            * @param classPK the class p k
3910            * @param status the status
3911            * @param start the lower bound of the range of message-boards messages
3912            * @param end the upper bound of the range of message-boards messages (not inclusive)
3913            * @return the range of matching message-boards messages
3914            */
3915            public java.util.List<MBMessage> findByC_C_S(long classNameId,
3916                    long classPK, int status, int start, int end);
3917    
3918            /**
3919            * Returns an ordered range of all the message-boards messages where classNameId = &#63; and classPK = &#63; and status = &#63;.
3920            *
3921            * <p>
3922            * 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 MBMessageModelImpl}. 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.
3923            * </p>
3924            *
3925            * @param classNameId the class name ID
3926            * @param classPK the class p k
3927            * @param status the status
3928            * @param start the lower bound of the range of message-boards messages
3929            * @param end the upper bound of the range of message-boards messages (not inclusive)
3930            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3931            * @return the ordered range of matching message-boards messages
3932            */
3933            public java.util.List<MBMessage> findByC_C_S(long classNameId,
3934                    long classPK, int status, int start, int end,
3935                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
3936    
3937            /**
3938            * Returns an ordered range of all the message-boards messages where classNameId = &#63; and classPK = &#63; and status = &#63;.
3939            *
3940            * <p>
3941            * 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 MBMessageModelImpl}. 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.
3942            * </p>
3943            *
3944            * @param classNameId the class name ID
3945            * @param classPK the class p k
3946            * @param status the status
3947            * @param start the lower bound of the range of message-boards messages
3948            * @param end the upper bound of the range of message-boards messages (not inclusive)
3949            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3950            * @param retrieveFromCache whether to retrieve from the finder cache
3951            * @return the ordered range of matching message-boards messages
3952            */
3953            public java.util.List<MBMessage> findByC_C_S(long classNameId,
3954                    long classPK, int status, int start, int end,
3955                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator,
3956                    boolean retrieveFromCache);
3957    
3958            /**
3959            * Returns the first message-boards message in the ordered set where classNameId = &#63; and classPK = &#63; and status = &#63;.
3960            *
3961            * @param classNameId the class name ID
3962            * @param classPK the class p k
3963            * @param status the status
3964            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3965            * @return the first matching message-boards message
3966            * @throws NoSuchMessageException if a matching message-boards message could not be found
3967            */
3968            public MBMessage findByC_C_S_First(long classNameId, long classPK,
3969                    int status,
3970                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
3971                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
3972    
3973            /**
3974            * Returns the first message-boards message in the ordered set where classNameId = &#63; and classPK = &#63; and status = &#63;.
3975            *
3976            * @param classNameId the class name ID
3977            * @param classPK the class p k
3978            * @param status the status
3979            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3980            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
3981            */
3982            public MBMessage fetchByC_C_S_First(long classNameId, long classPK,
3983                    int status,
3984                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
3985    
3986            /**
3987            * Returns the last message-boards message in the ordered set where classNameId = &#63; and classPK = &#63; and status = &#63;.
3988            *
3989            * @param classNameId the class name ID
3990            * @param classPK the class p k
3991            * @param status the status
3992            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3993            * @return the last matching message-boards message
3994            * @throws NoSuchMessageException if a matching message-boards message could not be found
3995            */
3996            public MBMessage findByC_C_S_Last(long classNameId, long classPK,
3997                    int status,
3998                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
3999                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
4000    
4001            /**
4002            * Returns the last message-boards message in the ordered set where classNameId = &#63; and classPK = &#63; and status = &#63;.
4003            *
4004            * @param classNameId the class name ID
4005            * @param classPK the class p k
4006            * @param status the status
4007            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4008            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
4009            */
4010            public MBMessage fetchByC_C_S_Last(long classNameId, long classPK,
4011                    int status,
4012                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
4013    
4014            /**
4015            * Returns the message-boards messages before and after the current message-boards message in the ordered set where classNameId = &#63; and classPK = &#63; and status = &#63;.
4016            *
4017            * @param messageId the primary key of the current message-boards message
4018            * @param classNameId the class name ID
4019            * @param classPK the class p k
4020            * @param status the status
4021            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4022            * @return the previous, current, and next message-boards message
4023            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
4024            */
4025            public MBMessage[] findByC_C_S_PrevAndNext(long messageId,
4026                    long classNameId, long classPK, int status,
4027                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
4028                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
4029    
4030            /**
4031            * Removes all the message-boards messages where classNameId = &#63; and classPK = &#63; and status = &#63; from the database.
4032            *
4033            * @param classNameId the class name ID
4034            * @param classPK the class p k
4035            * @param status the status
4036            */
4037            public void removeByC_C_S(long classNameId, long classPK, int status);
4038    
4039            /**
4040            * Returns the number of message-boards messages where classNameId = &#63; and classPK = &#63; and status = &#63;.
4041            *
4042            * @param classNameId the class name ID
4043            * @param classPK the class p k
4044            * @param status the status
4045            * @return the number of matching message-boards messages
4046            */
4047            public int countByC_C_S(long classNameId, long classPK, int status);
4048    
4049            /**
4050            * Returns all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; and answer = &#63;.
4051            *
4052            * @param groupId the group ID
4053            * @param categoryId the category ID
4054            * @param threadId the thread ID
4055            * @param answer the answer
4056            * @return the matching message-boards messages
4057            */
4058            public java.util.List<MBMessage> findByG_C_T_A(long groupId,
4059                    long categoryId, long threadId, boolean answer);
4060    
4061            /**
4062            * Returns a range of all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; and answer = &#63;.
4063            *
4064            * <p>
4065            * 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 MBMessageModelImpl}. 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.
4066            * </p>
4067            *
4068            * @param groupId the group ID
4069            * @param categoryId the category ID
4070            * @param threadId the thread ID
4071            * @param answer the answer
4072            * @param start the lower bound of the range of message-boards messages
4073            * @param end the upper bound of the range of message-boards messages (not inclusive)
4074            * @return the range of matching message-boards messages
4075            */
4076            public java.util.List<MBMessage> findByG_C_T_A(long groupId,
4077                    long categoryId, long threadId, boolean answer, int start, int end);
4078    
4079            /**
4080            * Returns an ordered range of all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; and answer = &#63;.
4081            *
4082            * <p>
4083            * 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 MBMessageModelImpl}. 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.
4084            * </p>
4085            *
4086            * @param groupId the group ID
4087            * @param categoryId the category ID
4088            * @param threadId the thread ID
4089            * @param answer the answer
4090            * @param start the lower bound of the range of message-boards messages
4091            * @param end the upper bound of the range of message-boards messages (not inclusive)
4092            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4093            * @return the ordered range of matching message-boards messages
4094            */
4095            public java.util.List<MBMessage> findByG_C_T_A(long groupId,
4096                    long categoryId, long threadId, boolean answer, int start, int end,
4097                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
4098    
4099            /**
4100            * Returns an ordered range of all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; and answer = &#63;.
4101            *
4102            * <p>
4103            * 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 MBMessageModelImpl}. 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.
4104            * </p>
4105            *
4106            * @param groupId the group ID
4107            * @param categoryId the category ID
4108            * @param threadId the thread ID
4109            * @param answer the answer
4110            * @param start the lower bound of the range of message-boards messages
4111            * @param end the upper bound of the range of message-boards messages (not inclusive)
4112            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4113            * @param retrieveFromCache whether to retrieve from the finder cache
4114            * @return the ordered range of matching message-boards messages
4115            */
4116            public java.util.List<MBMessage> findByG_C_T_A(long groupId,
4117                    long categoryId, long threadId, boolean answer, int start, int end,
4118                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator,
4119                    boolean retrieveFromCache);
4120    
4121            /**
4122            * Returns the first message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and threadId = &#63; and answer = &#63;.
4123            *
4124            * @param groupId the group ID
4125            * @param categoryId the category ID
4126            * @param threadId the thread ID
4127            * @param answer the answer
4128            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4129            * @return the first matching message-boards message
4130            * @throws NoSuchMessageException if a matching message-boards message could not be found
4131            */
4132            public MBMessage findByG_C_T_A_First(long groupId, long categoryId,
4133                    long threadId, boolean answer,
4134                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
4135                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
4136    
4137            /**
4138            * Returns the first message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and threadId = &#63; and answer = &#63;.
4139            *
4140            * @param groupId the group ID
4141            * @param categoryId the category ID
4142            * @param threadId the thread ID
4143            * @param answer the answer
4144            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4145            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
4146            */
4147            public MBMessage fetchByG_C_T_A_First(long groupId, long categoryId,
4148                    long threadId, boolean answer,
4149                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
4150    
4151            /**
4152            * Returns the last message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and threadId = &#63; and answer = &#63;.
4153            *
4154            * @param groupId the group ID
4155            * @param categoryId the category ID
4156            * @param threadId the thread ID
4157            * @param answer the answer
4158            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4159            * @return the last matching message-boards message
4160            * @throws NoSuchMessageException if a matching message-boards message could not be found
4161            */
4162            public MBMessage findByG_C_T_A_Last(long groupId, long categoryId,
4163                    long threadId, boolean answer,
4164                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
4165                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
4166    
4167            /**
4168            * Returns the last message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and threadId = &#63; and answer = &#63;.
4169            *
4170            * @param groupId the group ID
4171            * @param categoryId the category ID
4172            * @param threadId the thread ID
4173            * @param answer the answer
4174            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4175            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
4176            */
4177            public MBMessage fetchByG_C_T_A_Last(long groupId, long categoryId,
4178                    long threadId, boolean answer,
4179                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
4180    
4181            /**
4182            * Returns the message-boards messages before and after the current message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and threadId = &#63; and answer = &#63;.
4183            *
4184            * @param messageId the primary key of the current message-boards message
4185            * @param groupId the group ID
4186            * @param categoryId the category ID
4187            * @param threadId the thread ID
4188            * @param answer the answer
4189            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4190            * @return the previous, current, and next message-boards message
4191            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
4192            */
4193            public MBMessage[] findByG_C_T_A_PrevAndNext(long messageId, long groupId,
4194                    long categoryId, long threadId, boolean answer,
4195                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
4196                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
4197    
4198            /**
4199            * Returns all the message-boards messages that the user has permission to view where groupId = &#63; and categoryId = &#63; and threadId = &#63; and answer = &#63;.
4200            *
4201            * @param groupId the group ID
4202            * @param categoryId the category ID
4203            * @param threadId the thread ID
4204            * @param answer the answer
4205            * @return the matching message-boards messages that the user has permission to view
4206            */
4207            public java.util.List<MBMessage> filterFindByG_C_T_A(long groupId,
4208                    long categoryId, long threadId, boolean answer);
4209    
4210            /**
4211            * Returns a range of all the message-boards messages that the user has permission to view where groupId = &#63; and categoryId = &#63; and threadId = &#63; and answer = &#63;.
4212            *
4213            * <p>
4214            * 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 MBMessageModelImpl}. 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.
4215            * </p>
4216            *
4217            * @param groupId the group ID
4218            * @param categoryId the category ID
4219            * @param threadId the thread ID
4220            * @param answer the answer
4221            * @param start the lower bound of the range of message-boards messages
4222            * @param end the upper bound of the range of message-boards messages (not inclusive)
4223            * @return the range of matching message-boards messages that the user has permission to view
4224            */
4225            public java.util.List<MBMessage> filterFindByG_C_T_A(long groupId,
4226                    long categoryId, long threadId, boolean answer, int start, int end);
4227    
4228            /**
4229            * Returns an ordered range of all the message-boards messages that the user has permissions to view where groupId = &#63; and categoryId = &#63; and threadId = &#63; and answer = &#63;.
4230            *
4231            * <p>
4232            * 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 MBMessageModelImpl}. 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.
4233            * </p>
4234            *
4235            * @param groupId the group ID
4236            * @param categoryId the category ID
4237            * @param threadId the thread ID
4238            * @param answer the answer
4239            * @param start the lower bound of the range of message-boards messages
4240            * @param end the upper bound of the range of message-boards messages (not inclusive)
4241            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4242            * @return the ordered range of matching message-boards messages that the user has permission to view
4243            */
4244            public java.util.List<MBMessage> filterFindByG_C_T_A(long groupId,
4245                    long categoryId, long threadId, boolean answer, int start, int end,
4246                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
4247    
4248            /**
4249            * Returns the message-boards messages before and after the current message-boards message in the ordered set of message-boards messages that the user has permission to view where groupId = &#63; and categoryId = &#63; and threadId = &#63; and answer = &#63;.
4250            *
4251            * @param messageId the primary key of the current message-boards message
4252            * @param groupId the group ID
4253            * @param categoryId the category ID
4254            * @param threadId the thread ID
4255            * @param answer the answer
4256            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4257            * @return the previous, current, and next message-boards message
4258            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
4259            */
4260            public MBMessage[] filterFindByG_C_T_A_PrevAndNext(long messageId,
4261                    long groupId, long categoryId, long threadId, boolean answer,
4262                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
4263                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
4264    
4265            /**
4266            * Removes all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; and answer = &#63; from the database.
4267            *
4268            * @param groupId the group ID
4269            * @param categoryId the category ID
4270            * @param threadId the thread ID
4271            * @param answer the answer
4272            */
4273            public void removeByG_C_T_A(long groupId, long categoryId, long threadId,
4274                    boolean answer);
4275    
4276            /**
4277            * Returns the number of message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; and answer = &#63;.
4278            *
4279            * @param groupId the group ID
4280            * @param categoryId the category ID
4281            * @param threadId the thread ID
4282            * @param answer the answer
4283            * @return the number of matching message-boards messages
4284            */
4285            public int countByG_C_T_A(long groupId, long categoryId, long threadId,
4286                    boolean answer);
4287    
4288            /**
4289            * Returns the number of message-boards messages that the user has permission to view where groupId = &#63; and categoryId = &#63; and threadId = &#63; and answer = &#63;.
4290            *
4291            * @param groupId the group ID
4292            * @param categoryId the category ID
4293            * @param threadId the thread ID
4294            * @param answer the answer
4295            * @return the number of matching message-boards messages that the user has permission to view
4296            */
4297            public int filterCountByG_C_T_A(long groupId, long categoryId,
4298                    long threadId, boolean answer);
4299    
4300            /**
4301            * Returns all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
4302            *
4303            * @param groupId the group ID
4304            * @param categoryId the category ID
4305            * @param threadId the thread ID
4306            * @param status the status
4307            * @return the matching message-boards messages
4308            */
4309            public java.util.List<MBMessage> findByG_C_T_S(long groupId,
4310                    long categoryId, long threadId, int status);
4311    
4312            /**
4313            * Returns a range of all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
4314            *
4315            * <p>
4316            * 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 MBMessageModelImpl}. 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.
4317            * </p>
4318            *
4319            * @param groupId the group ID
4320            * @param categoryId the category ID
4321            * @param threadId the thread ID
4322            * @param status the status
4323            * @param start the lower bound of the range of message-boards messages
4324            * @param end the upper bound of the range of message-boards messages (not inclusive)
4325            * @return the range of matching message-boards messages
4326            */
4327            public java.util.List<MBMessage> findByG_C_T_S(long groupId,
4328                    long categoryId, long threadId, int status, int start, int end);
4329    
4330            /**
4331            * Returns an ordered range of all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
4332            *
4333            * <p>
4334            * 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 MBMessageModelImpl}. 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.
4335            * </p>
4336            *
4337            * @param groupId the group ID
4338            * @param categoryId the category ID
4339            * @param threadId the thread ID
4340            * @param status the status
4341            * @param start the lower bound of the range of message-boards messages
4342            * @param end the upper bound of the range of message-boards messages (not inclusive)
4343            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4344            * @return the ordered range of matching message-boards messages
4345            */
4346            public java.util.List<MBMessage> findByG_C_T_S(long groupId,
4347                    long categoryId, long threadId, int status, int start, int end,
4348                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
4349    
4350            /**
4351            * Returns an ordered range of all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
4352            *
4353            * <p>
4354            * 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 MBMessageModelImpl}. 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.
4355            * </p>
4356            *
4357            * @param groupId the group ID
4358            * @param categoryId the category ID
4359            * @param threadId the thread ID
4360            * @param status the status
4361            * @param start the lower bound of the range of message-boards messages
4362            * @param end the upper bound of the range of message-boards messages (not inclusive)
4363            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4364            * @param retrieveFromCache whether to retrieve from the finder cache
4365            * @return the ordered range of matching message-boards messages
4366            */
4367            public java.util.List<MBMessage> findByG_C_T_S(long groupId,
4368                    long categoryId, long threadId, int status, int start, int end,
4369                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator,
4370                    boolean retrieveFromCache);
4371    
4372            /**
4373            * Returns the first message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
4374            *
4375            * @param groupId the group ID
4376            * @param categoryId the category ID
4377            * @param threadId the thread ID
4378            * @param status the status
4379            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4380            * @return the first matching message-boards message
4381            * @throws NoSuchMessageException if a matching message-boards message could not be found
4382            */
4383            public MBMessage findByG_C_T_S_First(long groupId, long categoryId,
4384                    long threadId, int status,
4385                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
4386                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
4387    
4388            /**
4389            * Returns the first message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
4390            *
4391            * @param groupId the group ID
4392            * @param categoryId the category ID
4393            * @param threadId the thread ID
4394            * @param status the status
4395            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4396            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
4397            */
4398            public MBMessage fetchByG_C_T_S_First(long groupId, long categoryId,
4399                    long threadId, int status,
4400                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
4401    
4402            /**
4403            * Returns the last message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
4404            *
4405            * @param groupId the group ID
4406            * @param categoryId the category ID
4407            * @param threadId the thread ID
4408            * @param status the status
4409            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4410            * @return the last matching message-boards message
4411            * @throws NoSuchMessageException if a matching message-boards message could not be found
4412            */
4413            public MBMessage findByG_C_T_S_Last(long groupId, long categoryId,
4414                    long threadId, int status,
4415                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
4416                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
4417    
4418            /**
4419            * Returns the last message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
4420            *
4421            * @param groupId the group ID
4422            * @param categoryId the category ID
4423            * @param threadId the thread ID
4424            * @param status the status
4425            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4426            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
4427            */
4428            public MBMessage fetchByG_C_T_S_Last(long groupId, long categoryId,
4429                    long threadId, int status,
4430                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
4431    
4432            /**
4433            * Returns the message-boards messages before and after the current message-boards message in the ordered set where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
4434            *
4435            * @param messageId the primary key of the current message-boards message
4436            * @param groupId the group ID
4437            * @param categoryId the category ID
4438            * @param threadId the thread ID
4439            * @param status the status
4440            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4441            * @return the previous, current, and next message-boards message
4442            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
4443            */
4444            public MBMessage[] findByG_C_T_S_PrevAndNext(long messageId, long groupId,
4445                    long categoryId, long threadId, int status,
4446                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
4447                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
4448    
4449            /**
4450            * Returns all the message-boards messages that the user has permission to view where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
4451            *
4452            * @param groupId the group ID
4453            * @param categoryId the category ID
4454            * @param threadId the thread ID
4455            * @param status the status
4456            * @return the matching message-boards messages that the user has permission to view
4457            */
4458            public java.util.List<MBMessage> filterFindByG_C_T_S(long groupId,
4459                    long categoryId, long threadId, int status);
4460    
4461            /**
4462            * Returns a range of all the message-boards messages that the user has permission to view where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
4463            *
4464            * <p>
4465            * 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 MBMessageModelImpl}. 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.
4466            * </p>
4467            *
4468            * @param groupId the group ID
4469            * @param categoryId the category ID
4470            * @param threadId the thread ID
4471            * @param status the status
4472            * @param start the lower bound of the range of message-boards messages
4473            * @param end the upper bound of the range of message-boards messages (not inclusive)
4474            * @return the range of matching message-boards messages that the user has permission to view
4475            */
4476            public java.util.List<MBMessage> filterFindByG_C_T_S(long groupId,
4477                    long categoryId, long threadId, int status, int start, int end);
4478    
4479            /**
4480            * Returns an ordered range of all the message-boards messages that the user has permissions to view where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
4481            *
4482            * <p>
4483            * 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 MBMessageModelImpl}. 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.
4484            * </p>
4485            *
4486            * @param groupId the group ID
4487            * @param categoryId the category ID
4488            * @param threadId the thread ID
4489            * @param status the status
4490            * @param start the lower bound of the range of message-boards messages
4491            * @param end the upper bound of the range of message-boards messages (not inclusive)
4492            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4493            * @return the ordered range of matching message-boards messages that the user has permission to view
4494            */
4495            public java.util.List<MBMessage> filterFindByG_C_T_S(long groupId,
4496                    long categoryId, long threadId, int status, int start, int end,
4497                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
4498    
4499            /**
4500            * Returns the message-boards messages before and after the current message-boards message in the ordered set of message-boards messages that the user has permission to view where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
4501            *
4502            * @param messageId the primary key of the current message-boards message
4503            * @param groupId the group ID
4504            * @param categoryId the category ID
4505            * @param threadId the thread ID
4506            * @param status the status
4507            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4508            * @return the previous, current, and next message-boards message
4509            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
4510            */
4511            public MBMessage[] filterFindByG_C_T_S_PrevAndNext(long messageId,
4512                    long groupId, long categoryId, long threadId, int status,
4513                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
4514                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
4515    
4516            /**
4517            * Removes all the message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63; from the database.
4518            *
4519            * @param groupId the group ID
4520            * @param categoryId the category ID
4521            * @param threadId the thread ID
4522            * @param status the status
4523            */
4524            public void removeByG_C_T_S(long groupId, long categoryId, long threadId,
4525                    int status);
4526    
4527            /**
4528            * Returns the number of message-boards messages where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
4529            *
4530            * @param groupId the group ID
4531            * @param categoryId the category ID
4532            * @param threadId the thread ID
4533            * @param status the status
4534            * @return the number of matching message-boards messages
4535            */
4536            public int countByG_C_T_S(long groupId, long categoryId, long threadId,
4537                    int status);
4538    
4539            /**
4540            * Returns the number of message-boards messages that the user has permission to view where groupId = &#63; and categoryId = &#63; and threadId = &#63; and status = &#63;.
4541            *
4542            * @param groupId the group ID
4543            * @param categoryId the category ID
4544            * @param threadId the thread ID
4545            * @param status the status
4546            * @return the number of matching message-boards messages that the user has permission to view
4547            */
4548            public int filterCountByG_C_T_S(long groupId, long categoryId,
4549                    long threadId, int status);
4550    
4551            /**
4552            * Returns all the message-boards messages where userId = &#63; and classNameId = &#63; and classPK = &#63; and status = &#63;.
4553            *
4554            * @param userId the user ID
4555            * @param classNameId the class name ID
4556            * @param classPK the class p k
4557            * @param status the status
4558            * @return the matching message-boards messages
4559            */
4560            public java.util.List<MBMessage> findByU_C_C_S(long userId,
4561                    long classNameId, long classPK, int status);
4562    
4563            /**
4564            * Returns a range of all the message-boards messages where userId = &#63; and classNameId = &#63; and classPK = &#63; and status = &#63;.
4565            *
4566            * <p>
4567            * 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 MBMessageModelImpl}. 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.
4568            * </p>
4569            *
4570            * @param userId the user ID
4571            * @param classNameId the class name ID
4572            * @param classPK the class p k
4573            * @param status the status
4574            * @param start the lower bound of the range of message-boards messages
4575            * @param end the upper bound of the range of message-boards messages (not inclusive)
4576            * @return the range of matching message-boards messages
4577            */
4578            public java.util.List<MBMessage> findByU_C_C_S(long userId,
4579                    long classNameId, long classPK, int status, int start, int end);
4580    
4581            /**
4582            * Returns an ordered range of all the message-boards messages where userId = &#63; and classNameId = &#63; and classPK = &#63; and status = &#63;.
4583            *
4584            * <p>
4585            * 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 MBMessageModelImpl}. 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.
4586            * </p>
4587            *
4588            * @param userId the user ID
4589            * @param classNameId the class name ID
4590            * @param classPK the class p k
4591            * @param status the status
4592            * @param start the lower bound of the range of message-boards messages
4593            * @param end the upper bound of the range of message-boards messages (not inclusive)
4594            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4595            * @return the ordered range of matching message-boards messages
4596            */
4597            public java.util.List<MBMessage> findByU_C_C_S(long userId,
4598                    long classNameId, long classPK, int status, int start, int end,
4599                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
4600    
4601            /**
4602            * Returns an ordered range of all the message-boards messages where userId = &#63; and classNameId = &#63; and classPK = &#63; and status = &#63;.
4603            *
4604            * <p>
4605            * 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 MBMessageModelImpl}. 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.
4606            * </p>
4607            *
4608            * @param userId the user ID
4609            * @param classNameId the class name ID
4610            * @param classPK the class p k
4611            * @param status the status
4612            * @param start the lower bound of the range of message-boards messages
4613            * @param end the upper bound of the range of message-boards messages (not inclusive)
4614            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4615            * @param retrieveFromCache whether to retrieve from the finder cache
4616            * @return the ordered range of matching message-boards messages
4617            */
4618            public java.util.List<MBMessage> findByU_C_C_S(long userId,
4619                    long classNameId, long classPK, int status, int start, int end,
4620                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator,
4621                    boolean retrieveFromCache);
4622    
4623            /**
4624            * Returns the first message-boards message in the ordered set where userId = &#63; and classNameId = &#63; and classPK = &#63; and status = &#63;.
4625            *
4626            * @param userId the user ID
4627            * @param classNameId the class name ID
4628            * @param classPK the class p k
4629            * @param status the status
4630            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4631            * @return the first matching message-boards message
4632            * @throws NoSuchMessageException if a matching message-boards message could not be found
4633            */
4634            public MBMessage findByU_C_C_S_First(long userId, long classNameId,
4635                    long classPK, int status,
4636                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
4637                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
4638    
4639            /**
4640            * Returns the first message-boards message in the ordered set where userId = &#63; and classNameId = &#63; and classPK = &#63; and status = &#63;.
4641            *
4642            * @param userId the user ID
4643            * @param classNameId the class name ID
4644            * @param classPK the class p k
4645            * @param status the status
4646            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4647            * @return the first matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
4648            */
4649            public MBMessage fetchByU_C_C_S_First(long userId, long classNameId,
4650                    long classPK, int status,
4651                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
4652    
4653            /**
4654            * Returns the last message-boards message in the ordered set where userId = &#63; and classNameId = &#63; and classPK = &#63; and status = &#63;.
4655            *
4656            * @param userId the user ID
4657            * @param classNameId the class name ID
4658            * @param classPK the class p k
4659            * @param status the status
4660            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4661            * @return the last matching message-boards message
4662            * @throws NoSuchMessageException if a matching message-boards message could not be found
4663            */
4664            public MBMessage findByU_C_C_S_Last(long userId, long classNameId,
4665                    long classPK, int status,
4666                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
4667                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
4668    
4669            /**
4670            * Returns the last message-boards message in the ordered set where userId = &#63; and classNameId = &#63; and classPK = &#63; and status = &#63;.
4671            *
4672            * @param userId the user ID
4673            * @param classNameId the class name ID
4674            * @param classPK the class p k
4675            * @param status the status
4676            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4677            * @return the last matching message-boards message, or <code>null</code> if a matching message-boards message could not be found
4678            */
4679            public MBMessage fetchByU_C_C_S_Last(long userId, long classNameId,
4680                    long classPK, int status,
4681                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
4682    
4683            /**
4684            * Returns the message-boards messages before and after the current message-boards message in the ordered set where userId = &#63; and classNameId = &#63; and classPK = &#63; and status = &#63;.
4685            *
4686            * @param messageId the primary key of the current message-boards message
4687            * @param userId the user ID
4688            * @param classNameId the class name ID
4689            * @param classPK the class p k
4690            * @param status the status
4691            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4692            * @return the previous, current, and next message-boards message
4693            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
4694            */
4695            public MBMessage[] findByU_C_C_S_PrevAndNext(long messageId, long userId,
4696                    long classNameId, long classPK, int status,
4697                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator)
4698                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
4699    
4700            /**
4701            * Removes all the message-boards messages where userId = &#63; and classNameId = &#63; and classPK = &#63; and status = &#63; from the database.
4702            *
4703            * @param userId the user ID
4704            * @param classNameId the class name ID
4705            * @param classPK the class p k
4706            * @param status the status
4707            */
4708            public void removeByU_C_C_S(long userId, long classNameId, long classPK,
4709                    int status);
4710    
4711            /**
4712            * Returns the number of message-boards messages where userId = &#63; and classNameId = &#63; and classPK = &#63; and status = &#63;.
4713            *
4714            * @param userId the user ID
4715            * @param classNameId the class name ID
4716            * @param classPK the class p k
4717            * @param status the status
4718            * @return the number of matching message-boards messages
4719            */
4720            public int countByU_C_C_S(long userId, long classNameId, long classPK,
4721                    int status);
4722    
4723            /**
4724            * Caches the message-boards message in the entity cache if it is enabled.
4725            *
4726            * @param mbMessage the message-boards message
4727            */
4728            public void cacheResult(MBMessage mbMessage);
4729    
4730            /**
4731            * Caches the message-boards messages in the entity cache if it is enabled.
4732            *
4733            * @param mbMessages the message-boards messages
4734            */
4735            public void cacheResult(java.util.List<MBMessage> mbMessages);
4736    
4737            /**
4738            * Creates a new message-boards message with the primary key. Does not add the message-boards message to the database.
4739            *
4740            * @param messageId the primary key for the new message-boards message
4741            * @return the new message-boards message
4742            */
4743            public MBMessage create(long messageId);
4744    
4745            /**
4746            * Removes the message-boards message with the primary key from the database. Also notifies the appropriate model listeners.
4747            *
4748            * @param messageId the primary key of the message-boards message
4749            * @return the message-boards message that was removed
4750            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
4751            */
4752            public MBMessage remove(long messageId)
4753                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
4754    
4755            public MBMessage updateImpl(MBMessage mbMessage);
4756    
4757            /**
4758            * Returns the message-boards message with the primary key or throws a {@link NoSuchMessageException} if it could not be found.
4759            *
4760            * @param messageId the primary key of the message-boards message
4761            * @return the message-boards message
4762            * @throws NoSuchMessageException if a message-boards message with the primary key could not be found
4763            */
4764            public MBMessage findByPrimaryKey(long messageId)
4765                    throws com.liferay.portlet.messageboards.exception.NoSuchMessageException;
4766    
4767            /**
4768            * Returns the message-boards message with the primary key or returns <code>null</code> if it could not be found.
4769            *
4770            * @param messageId the primary key of the message-boards message
4771            * @return the message-boards message, or <code>null</code> if a message-boards message with the primary key could not be found
4772            */
4773            public MBMessage fetchByPrimaryKey(long messageId);
4774    
4775            @Override
4776            public java.util.Map<java.io.Serializable, MBMessage> fetchByPrimaryKeys(
4777                    java.util.Set<java.io.Serializable> primaryKeys);
4778    
4779            /**
4780            * Returns all the message-boards messages.
4781            *
4782            * @return the message-boards messages
4783            */
4784            public java.util.List<MBMessage> findAll();
4785    
4786            /**
4787            * Returns a range of all the message-boards messages.
4788            *
4789            * <p>
4790            * 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 MBMessageModelImpl}. 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.
4791            * </p>
4792            *
4793            * @param start the lower bound of the range of message-boards messages
4794            * @param end the upper bound of the range of message-boards messages (not inclusive)
4795            * @return the range of message-boards messages
4796            */
4797            public java.util.List<MBMessage> findAll(int start, int end);
4798    
4799            /**
4800            * Returns an ordered range of all the message-boards messages.
4801            *
4802            * <p>
4803            * 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 MBMessageModelImpl}. 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.
4804            * </p>
4805            *
4806            * @param start the lower bound of the range of message-boards messages
4807            * @param end the upper bound of the range of message-boards messages (not inclusive)
4808            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4809            * @return the ordered range of message-boards messages
4810            */
4811            public java.util.List<MBMessage> findAll(int start, int end,
4812                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator);
4813    
4814            /**
4815            * Returns an ordered range of all the message-boards messages.
4816            *
4817            * <p>
4818            * 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 MBMessageModelImpl}. 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.
4819            * </p>
4820            *
4821            * @param start the lower bound of the range of message-boards messages
4822            * @param end the upper bound of the range of message-boards messages (not inclusive)
4823            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4824            * @param retrieveFromCache whether to retrieve from the finder cache
4825            * @return the ordered range of message-boards messages
4826            */
4827            public java.util.List<MBMessage> findAll(int start, int end,
4828                    com.liferay.portal.kernel.util.OrderByComparator<MBMessage> orderByComparator,
4829                    boolean retrieveFromCache);
4830    
4831            /**
4832            * Removes all the message-boards messages from the database.
4833            */
4834            public void removeAll();
4835    
4836            /**
4837            * Returns the number of message-boards messages.
4838            *
4839            * @return the number of message-boards messages
4840            */
4841            public int countAll();
4842    
4843            @Override
4844            public java.util.Set<java.lang.String> getBadColumnNames();
4845    }