001 /** 002 * Copyright (c) 2000-2013 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.bookmarks.service.persistence; 016 017 import com.liferay.portal.service.persistence.BasePersistence; 018 019 import com.liferay.portlet.bookmarks.model.BookmarksEntry; 020 021 /** 022 * The persistence interface for the bookmarks entry service. 023 * 024 * <p> 025 * Caching information and settings can be found in <code>portal.properties</code> 026 * </p> 027 * 028 * @author Brian Wing Shun Chan 029 * @see BookmarksEntryPersistenceImpl 030 * @see BookmarksEntryUtil 031 * @generated 032 */ 033 public interface BookmarksEntryPersistence extends BasePersistence<BookmarksEntry> { 034 /* 035 * NOTE FOR DEVELOPERS: 036 * 037 * Never modify or reference this interface directly. Always use {@link BookmarksEntryUtil} to access the bookmarks entry persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 038 */ 039 040 /** 041 * Returns all the bookmarks entries where resourceBlockId = ?. 042 * 043 * @param resourceBlockId the resource block ID 044 * @return the matching bookmarks entries 045 * @throws SystemException if a system exception occurred 046 */ 047 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByResourceBlockId( 048 long resourceBlockId) 049 throws com.liferay.portal.kernel.exception.SystemException; 050 051 /** 052 * Returns a range of all the bookmarks entries where resourceBlockId = ?. 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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 resourceBlockId the resource block ID 059 * @param start the lower bound of the range of bookmarks entries 060 * @param end the upper bound of the range of bookmarks entries (not inclusive) 061 * @return the range of matching bookmarks entries 062 * @throws SystemException if a system exception occurred 063 */ 064 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByResourceBlockId( 065 long resourceBlockId, int start, int end) 066 throws com.liferay.portal.kernel.exception.SystemException; 067 068 /** 069 * Returns an ordered range of all the bookmarks entries where resourceBlockId = ?. 070 * 071 * <p> 072 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 073 * </p> 074 * 075 * @param resourceBlockId the resource block ID 076 * @param start the lower bound of the range of bookmarks entries 077 * @param end the upper bound of the range of bookmarks entries (not inclusive) 078 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 079 * @return the ordered range of matching bookmarks entries 080 * @throws SystemException if a system exception occurred 081 */ 082 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByResourceBlockId( 083 long resourceBlockId, int start, int end, 084 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 085 throws com.liferay.portal.kernel.exception.SystemException; 086 087 /** 088 * Returns the first bookmarks entry in the ordered set where resourceBlockId = ?. 089 * 090 * @param resourceBlockId the resource block ID 091 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 092 * @return the first matching bookmarks entry 093 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 094 * @throws SystemException if a system exception occurred 095 */ 096 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByResourceBlockId_First( 097 long resourceBlockId, 098 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 099 throws com.liferay.portal.kernel.exception.SystemException, 100 com.liferay.portlet.bookmarks.NoSuchEntryException; 101 102 /** 103 * Returns the first bookmarks entry in the ordered set where resourceBlockId = ?. 104 * 105 * @param resourceBlockId the resource block ID 106 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 107 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 108 * @throws SystemException if a system exception occurred 109 */ 110 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByResourceBlockId_First( 111 long resourceBlockId, 112 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 113 throws com.liferay.portal.kernel.exception.SystemException; 114 115 /** 116 * Returns the last bookmarks entry in the ordered set where resourceBlockId = ?. 117 * 118 * @param resourceBlockId the resource block ID 119 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 120 * @return the last matching bookmarks entry 121 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 122 * @throws SystemException if a system exception occurred 123 */ 124 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByResourceBlockId_Last( 125 long resourceBlockId, 126 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 127 throws com.liferay.portal.kernel.exception.SystemException, 128 com.liferay.portlet.bookmarks.NoSuchEntryException; 129 130 /** 131 * Returns the last bookmarks entry in the ordered set where resourceBlockId = ?. 132 * 133 * @param resourceBlockId the resource block ID 134 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 135 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 136 * @throws SystemException if a system exception occurred 137 */ 138 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByResourceBlockId_Last( 139 long resourceBlockId, 140 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 141 throws com.liferay.portal.kernel.exception.SystemException; 142 143 /** 144 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where resourceBlockId = ?. 145 * 146 * @param entryId the primary key of the current bookmarks entry 147 * @param resourceBlockId the resource block ID 148 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 149 * @return the previous, current, and next bookmarks entry 150 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 151 * @throws SystemException if a system exception occurred 152 */ 153 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByResourceBlockId_PrevAndNext( 154 long entryId, long resourceBlockId, 155 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 156 throws com.liferay.portal.kernel.exception.SystemException, 157 com.liferay.portlet.bookmarks.NoSuchEntryException; 158 159 /** 160 * Removes all the bookmarks entries where resourceBlockId = ? from the database. 161 * 162 * @param resourceBlockId the resource block ID 163 * @throws SystemException if a system exception occurred 164 */ 165 public void removeByResourceBlockId(long resourceBlockId) 166 throws com.liferay.portal.kernel.exception.SystemException; 167 168 /** 169 * Returns the number of bookmarks entries where resourceBlockId = ?. 170 * 171 * @param resourceBlockId the resource block ID 172 * @return the number of matching bookmarks entries 173 * @throws SystemException if a system exception occurred 174 */ 175 public int countByResourceBlockId(long resourceBlockId) 176 throws com.liferay.portal.kernel.exception.SystemException; 177 178 /** 179 * Returns all the bookmarks entries where uuid = ?. 180 * 181 * @param uuid the uuid 182 * @return the matching bookmarks entries 183 * @throws SystemException if a system exception occurred 184 */ 185 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid( 186 java.lang.String uuid) 187 throws com.liferay.portal.kernel.exception.SystemException; 188 189 /** 190 * Returns a range of all the bookmarks entries where uuid = ?. 191 * 192 * <p> 193 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 194 * </p> 195 * 196 * @param uuid the uuid 197 * @param start the lower bound of the range of bookmarks entries 198 * @param end the upper bound of the range of bookmarks entries (not inclusive) 199 * @return the range of matching bookmarks entries 200 * @throws SystemException if a system exception occurred 201 */ 202 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid( 203 java.lang.String uuid, int start, int end) 204 throws com.liferay.portal.kernel.exception.SystemException; 205 206 /** 207 * Returns an ordered range of all the bookmarks entries where uuid = ?. 208 * 209 * <p> 210 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 211 * </p> 212 * 213 * @param uuid the uuid 214 * @param start the lower bound of the range of bookmarks entries 215 * @param end the upper bound of the range of bookmarks entries (not inclusive) 216 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 217 * @return the ordered range of matching bookmarks entries 218 * @throws SystemException if a system exception occurred 219 */ 220 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid( 221 java.lang.String uuid, int start, int end, 222 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 223 throws com.liferay.portal.kernel.exception.SystemException; 224 225 /** 226 * Returns the first bookmarks entry in the ordered set where uuid = ?. 227 * 228 * @param uuid the uuid 229 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 230 * @return the first matching bookmarks entry 231 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 232 * @throws SystemException if a system exception occurred 233 */ 234 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_First( 235 java.lang.String uuid, 236 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 237 throws com.liferay.portal.kernel.exception.SystemException, 238 com.liferay.portlet.bookmarks.NoSuchEntryException; 239 240 /** 241 * Returns the first bookmarks entry in the ordered set where uuid = ?. 242 * 243 * @param uuid the uuid 244 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 245 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 246 * @throws SystemException if a system exception occurred 247 */ 248 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_First( 249 java.lang.String uuid, 250 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 251 throws com.liferay.portal.kernel.exception.SystemException; 252 253 /** 254 * Returns the last bookmarks entry in the ordered set where uuid = ?. 255 * 256 * @param uuid the uuid 257 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 258 * @return the last matching bookmarks entry 259 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 260 * @throws SystemException if a system exception occurred 261 */ 262 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_Last( 263 java.lang.String uuid, 264 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 265 throws com.liferay.portal.kernel.exception.SystemException, 266 com.liferay.portlet.bookmarks.NoSuchEntryException; 267 268 /** 269 * Returns the last bookmarks entry in the ordered set where uuid = ?. 270 * 271 * @param uuid the uuid 272 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 273 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 274 * @throws SystemException if a system exception occurred 275 */ 276 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_Last( 277 java.lang.String uuid, 278 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 279 throws com.liferay.portal.kernel.exception.SystemException; 280 281 /** 282 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where uuid = ?. 283 * 284 * @param entryId the primary key of the current bookmarks entry 285 * @param uuid the uuid 286 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 287 * @return the previous, current, and next bookmarks entry 288 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 289 * @throws SystemException if a system exception occurred 290 */ 291 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByUuid_PrevAndNext( 292 long entryId, java.lang.String uuid, 293 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 294 throws com.liferay.portal.kernel.exception.SystemException, 295 com.liferay.portlet.bookmarks.NoSuchEntryException; 296 297 /** 298 * Removes all the bookmarks entries where uuid = ? from the database. 299 * 300 * @param uuid the uuid 301 * @throws SystemException if a system exception occurred 302 */ 303 public void removeByUuid(java.lang.String uuid) 304 throws com.liferay.portal.kernel.exception.SystemException; 305 306 /** 307 * Returns the number of bookmarks entries where uuid = ?. 308 * 309 * @param uuid the uuid 310 * @return the number of matching bookmarks entries 311 * @throws SystemException if a system exception occurred 312 */ 313 public int countByUuid(java.lang.String uuid) 314 throws com.liferay.portal.kernel.exception.SystemException; 315 316 /** 317 * Returns the bookmarks entry where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.bookmarks.NoSuchEntryException} if it could not be found. 318 * 319 * @param uuid the uuid 320 * @param groupId the group ID 321 * @return the matching bookmarks entry 322 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 323 * @throws SystemException if a system exception occurred 324 */ 325 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByUUID_G( 326 java.lang.String uuid, long groupId) 327 throws com.liferay.portal.kernel.exception.SystemException, 328 com.liferay.portlet.bookmarks.NoSuchEntryException; 329 330 /** 331 * Returns the bookmarks entry where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 332 * 333 * @param uuid the uuid 334 * @param groupId the group ID 335 * @return the matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 336 * @throws SystemException if a system exception occurred 337 */ 338 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUUID_G( 339 java.lang.String uuid, long groupId) 340 throws com.liferay.portal.kernel.exception.SystemException; 341 342 /** 343 * Returns the bookmarks entry where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 344 * 345 * @param uuid the uuid 346 * @param groupId the group ID 347 * @param retrieveFromCache whether to use the finder cache 348 * @return the matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 349 * @throws SystemException if a system exception occurred 350 */ 351 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUUID_G( 352 java.lang.String uuid, long groupId, boolean retrieveFromCache) 353 throws com.liferay.portal.kernel.exception.SystemException; 354 355 /** 356 * Removes the bookmarks entry where uuid = ? and groupId = ? from the database. 357 * 358 * @param uuid the uuid 359 * @param groupId the group ID 360 * @return the bookmarks entry that was removed 361 * @throws SystemException if a system exception occurred 362 */ 363 public com.liferay.portlet.bookmarks.model.BookmarksEntry removeByUUID_G( 364 java.lang.String uuid, long groupId) 365 throws com.liferay.portal.kernel.exception.SystemException, 366 com.liferay.portlet.bookmarks.NoSuchEntryException; 367 368 /** 369 * Returns the number of bookmarks entries where uuid = ? and groupId = ?. 370 * 371 * @param uuid the uuid 372 * @param groupId the group ID 373 * @return the number of matching bookmarks entries 374 * @throws SystemException if a system exception occurred 375 */ 376 public int countByUUID_G(java.lang.String uuid, long groupId) 377 throws com.liferay.portal.kernel.exception.SystemException; 378 379 /** 380 * Returns all the bookmarks entries where uuid = ? and companyId = ?. 381 * 382 * @param uuid the uuid 383 * @param companyId the company ID 384 * @return the matching bookmarks entries 385 * @throws SystemException if a system exception occurred 386 */ 387 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid_C( 388 java.lang.String uuid, long companyId) 389 throws com.liferay.portal.kernel.exception.SystemException; 390 391 /** 392 * Returns a range of all the bookmarks entries where uuid = ? and companyId = ?. 393 * 394 * <p> 395 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 396 * </p> 397 * 398 * @param uuid the uuid 399 * @param companyId the company ID 400 * @param start the lower bound of the range of bookmarks entries 401 * @param end the upper bound of the range of bookmarks entries (not inclusive) 402 * @return the range of matching bookmarks entries 403 * @throws SystemException if a system exception occurred 404 */ 405 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid_C( 406 java.lang.String uuid, long companyId, int start, int end) 407 throws com.liferay.portal.kernel.exception.SystemException; 408 409 /** 410 * Returns an ordered range of all the bookmarks entries where uuid = ? and companyId = ?. 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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 uuid the uuid 417 * @param companyId the company ID 418 * @param start the lower bound of the range of bookmarks entries 419 * @param end the upper bound of the range of bookmarks entries (not inclusive) 420 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 421 * @return the ordered range of matching bookmarks entries 422 * @throws SystemException if a system exception occurred 423 */ 424 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByUuid_C( 425 java.lang.String uuid, long companyId, int start, int end, 426 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 427 throws com.liferay.portal.kernel.exception.SystemException; 428 429 /** 430 * Returns the first bookmarks entry in the ordered set where uuid = ? and companyId = ?. 431 * 432 * @param uuid the uuid 433 * @param companyId the company ID 434 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 435 * @return the first matching bookmarks entry 436 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 437 * @throws SystemException if a system exception occurred 438 */ 439 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_C_First( 440 java.lang.String uuid, long companyId, 441 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 442 throws com.liferay.portal.kernel.exception.SystemException, 443 com.liferay.portlet.bookmarks.NoSuchEntryException; 444 445 /** 446 * Returns the first bookmarks entry in the ordered set where uuid = ? and companyId = ?. 447 * 448 * @param uuid the uuid 449 * @param companyId the company ID 450 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 451 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 452 * @throws SystemException if a system exception occurred 453 */ 454 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_C_First( 455 java.lang.String uuid, long companyId, 456 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 457 throws com.liferay.portal.kernel.exception.SystemException; 458 459 /** 460 * Returns the last bookmarks entry in the ordered set where uuid = ? and companyId = ?. 461 * 462 * @param uuid the uuid 463 * @param companyId the company ID 464 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 465 * @return the last matching bookmarks entry 466 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 467 * @throws SystemException if a system exception occurred 468 */ 469 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByUuid_C_Last( 470 java.lang.String uuid, long companyId, 471 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 472 throws com.liferay.portal.kernel.exception.SystemException, 473 com.liferay.portlet.bookmarks.NoSuchEntryException; 474 475 /** 476 * Returns the last bookmarks entry in the ordered set where uuid = ? and companyId = ?. 477 * 478 * @param uuid the uuid 479 * @param companyId the company ID 480 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 481 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 482 * @throws SystemException if a system exception occurred 483 */ 484 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByUuid_C_Last( 485 java.lang.String uuid, long companyId, 486 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 487 throws com.liferay.portal.kernel.exception.SystemException; 488 489 /** 490 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where uuid = ? and companyId = ?. 491 * 492 * @param entryId the primary key of the current bookmarks entry 493 * @param uuid the uuid 494 * @param companyId the company ID 495 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 496 * @return the previous, current, and next bookmarks entry 497 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 498 * @throws SystemException if a system exception occurred 499 */ 500 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByUuid_C_PrevAndNext( 501 long entryId, java.lang.String uuid, long companyId, 502 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 503 throws com.liferay.portal.kernel.exception.SystemException, 504 com.liferay.portlet.bookmarks.NoSuchEntryException; 505 506 /** 507 * Removes all the bookmarks entries where uuid = ? and companyId = ? from the database. 508 * 509 * @param uuid the uuid 510 * @param companyId the company ID 511 * @throws SystemException if a system exception occurred 512 */ 513 public void removeByUuid_C(java.lang.String uuid, long companyId) 514 throws com.liferay.portal.kernel.exception.SystemException; 515 516 /** 517 * Returns the number of bookmarks entries where uuid = ? and companyId = ?. 518 * 519 * @param uuid the uuid 520 * @param companyId the company ID 521 * @return the number of matching bookmarks entries 522 * @throws SystemException if a system exception occurred 523 */ 524 public int countByUuid_C(java.lang.String uuid, long companyId) 525 throws com.liferay.portal.kernel.exception.SystemException; 526 527 /** 528 * Returns all the bookmarks entries where groupId = ? and folderId = ?. 529 * 530 * @param groupId the group ID 531 * @param folderId the folder ID 532 * @return the matching bookmarks entries 533 * @throws SystemException if a system exception occurred 534 */ 535 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 536 long groupId, long folderId) 537 throws com.liferay.portal.kernel.exception.SystemException; 538 539 /** 540 * Returns a range of all the bookmarks entries where groupId = ? and folderId = ?. 541 * 542 * <p> 543 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 544 * </p> 545 * 546 * @param groupId the group ID 547 * @param folderId the folder ID 548 * @param start the lower bound of the range of bookmarks entries 549 * @param end the upper bound of the range of bookmarks entries (not inclusive) 550 * @return the range of matching bookmarks entries 551 * @throws SystemException if a system exception occurred 552 */ 553 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 554 long groupId, long folderId, int start, int end) 555 throws com.liferay.portal.kernel.exception.SystemException; 556 557 /** 558 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = ?. 559 * 560 * <p> 561 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 562 * </p> 563 * 564 * @param groupId the group ID 565 * @param folderId the folder ID 566 * @param start the lower bound of the range of bookmarks entries 567 * @param end the upper bound of the range of bookmarks entries (not inclusive) 568 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 569 * @return the ordered range of matching bookmarks entries 570 * @throws SystemException if a system exception occurred 571 */ 572 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 573 long groupId, long folderId, int start, int end, 574 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 575 throws com.liferay.portal.kernel.exception.SystemException; 576 577 /** 578 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ?. 579 * 580 * @param groupId the group ID 581 * @param folderId the folder ID 582 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 583 * @return the first matching bookmarks entry 584 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 585 * @throws SystemException if a system exception occurred 586 */ 587 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_First( 588 long groupId, long folderId, 589 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 590 throws com.liferay.portal.kernel.exception.SystemException, 591 com.liferay.portlet.bookmarks.NoSuchEntryException; 592 593 /** 594 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ?. 595 * 596 * @param groupId the group ID 597 * @param folderId the folder ID 598 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 599 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 600 * @throws SystemException if a system exception occurred 601 */ 602 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_First( 603 long groupId, long folderId, 604 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 605 throws com.liferay.portal.kernel.exception.SystemException; 606 607 /** 608 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ?. 609 * 610 * @param groupId the group ID 611 * @param folderId the folder ID 612 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 613 * @return the last matching bookmarks entry 614 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 615 * @throws SystemException if a system exception occurred 616 */ 617 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_Last( 618 long groupId, long folderId, 619 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 620 throws com.liferay.portal.kernel.exception.SystemException, 621 com.liferay.portlet.bookmarks.NoSuchEntryException; 622 623 /** 624 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ?. 625 * 626 * @param groupId the group ID 627 * @param folderId the folder ID 628 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 629 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 630 * @throws SystemException if a system exception occurred 631 */ 632 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_Last( 633 long groupId, long folderId, 634 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 635 throws com.liferay.portal.kernel.exception.SystemException; 636 637 /** 638 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and folderId = ?. 639 * 640 * @param entryId the primary key of the current bookmarks entry 641 * @param groupId the group ID 642 * @param folderId the folder ID 643 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 644 * @return the previous, current, and next bookmarks entry 645 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 646 * @throws SystemException if a system exception occurred 647 */ 648 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_PrevAndNext( 649 long entryId, long groupId, long folderId, 650 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 651 throws com.liferay.portal.kernel.exception.SystemException, 652 com.liferay.portlet.bookmarks.NoSuchEntryException; 653 654 /** 655 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ?. 656 * 657 * @param groupId the group ID 658 * @param folderId the folder ID 659 * @return the matching bookmarks entries that the user has permission to view 660 * @throws SystemException if a system exception occurred 661 */ 662 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 663 long groupId, long folderId) 664 throws com.liferay.portal.kernel.exception.SystemException; 665 666 /** 667 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ?. 668 * 669 * <p> 670 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 671 * </p> 672 * 673 * @param groupId the group ID 674 * @param folderId the folder ID 675 * @param start the lower bound of the range of bookmarks entries 676 * @param end the upper bound of the range of bookmarks entries (not inclusive) 677 * @return the range of matching bookmarks entries that the user has permission to view 678 * @throws SystemException if a system exception occurred 679 */ 680 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 681 long groupId, long folderId, int start, int end) 682 throws com.liferay.portal.kernel.exception.SystemException; 683 684 /** 685 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and folderId = ?. 686 * 687 * <p> 688 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 689 * </p> 690 * 691 * @param groupId the group ID 692 * @param folderId the folder ID 693 * @param start the lower bound of the range of bookmarks entries 694 * @param end the upper bound of the range of bookmarks entries (not inclusive) 695 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 696 * @return the ordered range of matching bookmarks entries that the user has permission to view 697 * @throws SystemException if a system exception occurred 698 */ 699 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 700 long groupId, long folderId, int start, int end, 701 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 702 throws com.liferay.portal.kernel.exception.SystemException; 703 704 /** 705 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set of bookmarks entries that the user has permission to view where groupId = ? and folderId = ?. 706 * 707 * @param entryId the primary key of the current bookmarks entry 708 * @param groupId the group ID 709 * @param folderId the folder ID 710 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 711 * @return the previous, current, and next bookmarks entry 712 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 713 * @throws SystemException if a system exception occurred 714 */ 715 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_PrevAndNext( 716 long entryId, long groupId, long folderId, 717 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 718 throws com.liferay.portal.kernel.exception.SystemException, 719 com.liferay.portlet.bookmarks.NoSuchEntryException; 720 721 /** 722 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 723 * 724 * @param groupId the group ID 725 * @param folderIds the folder IDs 726 * @return the matching bookmarks entries that the user has permission to view 727 * @throws SystemException if a system exception occurred 728 */ 729 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 730 long groupId, long[] folderIds) 731 throws com.liferay.portal.kernel.exception.SystemException; 732 733 /** 734 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 735 * 736 * <p> 737 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 738 * </p> 739 * 740 * @param groupId the group ID 741 * @param folderIds the folder IDs 742 * @param start the lower bound of the range of bookmarks entries 743 * @param end the upper bound of the range of bookmarks entries (not inclusive) 744 * @return the range of matching bookmarks entries that the user has permission to view 745 * @throws SystemException if a system exception occurred 746 */ 747 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 748 long groupId, long[] folderIds, int start, int end) 749 throws com.liferay.portal.kernel.exception.SystemException; 750 751 /** 752 * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 753 * 754 * <p> 755 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 756 * </p> 757 * 758 * @param groupId the group ID 759 * @param folderIds the folder IDs 760 * @param start the lower bound of the range of bookmarks entries 761 * @param end the upper bound of the range of bookmarks entries (not inclusive) 762 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 763 * @return the ordered range of matching bookmarks entries that the user has permission to view 764 * @throws SystemException if a system exception occurred 765 */ 766 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 767 long groupId, long[] folderIds, int start, int end, 768 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 769 throws com.liferay.portal.kernel.exception.SystemException; 770 771 /** 772 * Returns all the bookmarks entries where groupId = ? and folderId = any ?. 773 * 774 * <p> 775 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 776 * </p> 777 * 778 * @param groupId the group ID 779 * @param folderIds the folder IDs 780 * @return the matching bookmarks entries 781 * @throws SystemException if a system exception occurred 782 */ 783 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 784 long groupId, long[] folderIds) 785 throws com.liferay.portal.kernel.exception.SystemException; 786 787 /** 788 * Returns a range of all the bookmarks entries where groupId = ? and folderId = any ?. 789 * 790 * <p> 791 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 792 * </p> 793 * 794 * @param groupId the group ID 795 * @param folderIds the folder IDs 796 * @param start the lower bound of the range of bookmarks entries 797 * @param end the upper bound of the range of bookmarks entries (not inclusive) 798 * @return the range of matching bookmarks entries 799 * @throws SystemException if a system exception occurred 800 */ 801 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 802 long groupId, long[] folderIds, int start, int end) 803 throws com.liferay.portal.kernel.exception.SystemException; 804 805 /** 806 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = any ?. 807 * 808 * <p> 809 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 810 * </p> 811 * 812 * @param groupId the group ID 813 * @param folderIds the folder IDs 814 * @param start the lower bound of the range of bookmarks entries 815 * @param end the upper bound of the range of bookmarks entries (not inclusive) 816 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 817 * @return the ordered range of matching bookmarks entries 818 * @throws SystemException if a system exception occurred 819 */ 820 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 821 long groupId, long[] folderIds, int start, int end, 822 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 823 throws com.liferay.portal.kernel.exception.SystemException; 824 825 /** 826 * Removes all the bookmarks entries where groupId = ? and folderId = ? from the database. 827 * 828 * @param groupId the group ID 829 * @param folderId the folder ID 830 * @throws SystemException if a system exception occurred 831 */ 832 public void removeByG_F(long groupId, long folderId) 833 throws com.liferay.portal.kernel.exception.SystemException; 834 835 /** 836 * Returns the number of bookmarks entries where groupId = ? and folderId = ?. 837 * 838 * @param groupId the group ID 839 * @param folderId the folder ID 840 * @return the number of matching bookmarks entries 841 * @throws SystemException if a system exception occurred 842 */ 843 public int countByG_F(long groupId, long folderId) 844 throws com.liferay.portal.kernel.exception.SystemException; 845 846 /** 847 * Returns the number of bookmarks entries where groupId = ? and folderId = any ?. 848 * 849 * @param groupId the group ID 850 * @param folderIds the folder IDs 851 * @return the number of matching bookmarks entries 852 * @throws SystemException if a system exception occurred 853 */ 854 public int countByG_F(long groupId, long[] folderIds) 855 throws com.liferay.portal.kernel.exception.SystemException; 856 857 /** 858 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = ?. 859 * 860 * @param groupId the group ID 861 * @param folderId the folder ID 862 * @return the number of matching bookmarks entries that the user has permission to view 863 * @throws SystemException if a system exception occurred 864 */ 865 public int filterCountByG_F(long groupId, long folderId) 866 throws com.liferay.portal.kernel.exception.SystemException; 867 868 /** 869 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 870 * 871 * @param groupId the group ID 872 * @param folderIds the folder IDs 873 * @return the number of matching bookmarks entries that the user has permission to view 874 * @throws SystemException if a system exception occurred 875 */ 876 public int filterCountByG_F(long groupId, long[] folderIds) 877 throws com.liferay.portal.kernel.exception.SystemException; 878 879 /** 880 * Returns all the bookmarks entries where groupId = ? and status = ?. 881 * 882 * @param groupId the group ID 883 * @param status the status 884 * @return the matching bookmarks entries 885 * @throws SystemException if a system exception occurred 886 */ 887 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_S( 888 long groupId, int status) 889 throws com.liferay.portal.kernel.exception.SystemException; 890 891 /** 892 * Returns a range of all the bookmarks entries where groupId = ? and status = ?. 893 * 894 * <p> 895 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 896 * </p> 897 * 898 * @param groupId the group ID 899 * @param status the status 900 * @param start the lower bound of the range of bookmarks entries 901 * @param end the upper bound of the range of bookmarks entries (not inclusive) 902 * @return the range of matching bookmarks entries 903 * @throws SystemException if a system exception occurred 904 */ 905 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_S( 906 long groupId, int status, int start, int end) 907 throws com.liferay.portal.kernel.exception.SystemException; 908 909 /** 910 * Returns an ordered range of all the bookmarks entries where groupId = ? and status = ?. 911 * 912 * <p> 913 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 914 * </p> 915 * 916 * @param groupId the group ID 917 * @param status the status 918 * @param start the lower bound of the range of bookmarks entries 919 * @param end the upper bound of the range of bookmarks entries (not inclusive) 920 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 921 * @return the ordered range of matching bookmarks entries 922 * @throws SystemException if a system exception occurred 923 */ 924 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_S( 925 long groupId, int status, int start, int end, 926 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 927 throws com.liferay.portal.kernel.exception.SystemException; 928 929 /** 930 * Returns the first bookmarks entry in the ordered set where groupId = ? and status = ?. 931 * 932 * @param groupId the group ID 933 * @param status the status 934 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 935 * @return the first matching bookmarks entry 936 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 937 * @throws SystemException if a system exception occurred 938 */ 939 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_S_First( 940 long groupId, int status, 941 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 942 throws com.liferay.portal.kernel.exception.SystemException, 943 com.liferay.portlet.bookmarks.NoSuchEntryException; 944 945 /** 946 * Returns the first bookmarks entry in the ordered set where groupId = ? and status = ?. 947 * 948 * @param groupId the group ID 949 * @param status the status 950 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 951 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 952 * @throws SystemException if a system exception occurred 953 */ 954 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_S_First( 955 long groupId, int status, 956 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 957 throws com.liferay.portal.kernel.exception.SystemException; 958 959 /** 960 * Returns the last bookmarks entry in the ordered set where groupId = ? and status = ?. 961 * 962 * @param groupId the group ID 963 * @param status the status 964 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 965 * @return the last matching bookmarks entry 966 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 967 * @throws SystemException if a system exception occurred 968 */ 969 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_S_Last( 970 long groupId, int status, 971 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 972 throws com.liferay.portal.kernel.exception.SystemException, 973 com.liferay.portlet.bookmarks.NoSuchEntryException; 974 975 /** 976 * Returns the last bookmarks entry in the ordered set where groupId = ? and status = ?. 977 * 978 * @param groupId the group ID 979 * @param status the status 980 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 981 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 982 * @throws SystemException if a system exception occurred 983 */ 984 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_S_Last( 985 long groupId, int status, 986 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 987 throws com.liferay.portal.kernel.exception.SystemException; 988 989 /** 990 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and status = ?. 991 * 992 * @param entryId the primary key of the current bookmarks entry 993 * @param groupId the group ID 994 * @param status the status 995 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 996 * @return the previous, current, and next bookmarks entry 997 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 998 * @throws SystemException if a system exception occurred 999 */ 1000 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_S_PrevAndNext( 1001 long entryId, long groupId, int status, 1002 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1003 throws com.liferay.portal.kernel.exception.SystemException, 1004 com.liferay.portlet.bookmarks.NoSuchEntryException; 1005 1006 /** 1007 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and status = ?. 1008 * 1009 * @param groupId the group ID 1010 * @param status the status 1011 * @return the matching bookmarks entries that the user has permission to view 1012 * @throws SystemException if a system exception occurred 1013 */ 1014 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_S( 1015 long groupId, int status) 1016 throws com.liferay.portal.kernel.exception.SystemException; 1017 1018 /** 1019 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and status = ?. 1020 * 1021 * <p> 1022 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 1023 * </p> 1024 * 1025 * @param groupId the group ID 1026 * @param status the status 1027 * @param start the lower bound of the range of bookmarks entries 1028 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1029 * @return the range of matching bookmarks entries that the user has permission to view 1030 * @throws SystemException if a system exception occurred 1031 */ 1032 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_S( 1033 long groupId, int status, int start, int end) 1034 throws com.liferay.portal.kernel.exception.SystemException; 1035 1036 /** 1037 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and status = ?. 1038 * 1039 * <p> 1040 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 1041 * </p> 1042 * 1043 * @param groupId the group ID 1044 * @param status the status 1045 * @param start the lower bound of the range of bookmarks entries 1046 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1047 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1048 * @return the ordered range of matching bookmarks entries that the user has permission to view 1049 * @throws SystemException if a system exception occurred 1050 */ 1051 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_S( 1052 long groupId, int status, int start, int end, 1053 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1054 throws com.liferay.portal.kernel.exception.SystemException; 1055 1056 /** 1057 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set of bookmarks entries that the user has permission to view where groupId = ? and status = ?. 1058 * 1059 * @param entryId the primary key of the current bookmarks entry 1060 * @param groupId the group ID 1061 * @param status the status 1062 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1063 * @return the previous, current, and next bookmarks entry 1064 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1065 * @throws SystemException if a system exception occurred 1066 */ 1067 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_S_PrevAndNext( 1068 long entryId, long groupId, int status, 1069 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1070 throws com.liferay.portal.kernel.exception.SystemException, 1071 com.liferay.portlet.bookmarks.NoSuchEntryException; 1072 1073 /** 1074 * Removes all the bookmarks entries where groupId = ? and status = ? from the database. 1075 * 1076 * @param groupId the group ID 1077 * @param status the status 1078 * @throws SystemException if a system exception occurred 1079 */ 1080 public void removeByG_S(long groupId, int status) 1081 throws com.liferay.portal.kernel.exception.SystemException; 1082 1083 /** 1084 * Returns the number of bookmarks entries where groupId = ? and status = ?. 1085 * 1086 * @param groupId the group ID 1087 * @param status the status 1088 * @return the number of matching bookmarks entries 1089 * @throws SystemException if a system exception occurred 1090 */ 1091 public int countByG_S(long groupId, int status) 1092 throws com.liferay.portal.kernel.exception.SystemException; 1093 1094 /** 1095 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and status = ?. 1096 * 1097 * @param groupId the group ID 1098 * @param status the status 1099 * @return the number of matching bookmarks entries that the user has permission to view 1100 * @throws SystemException if a system exception occurred 1101 */ 1102 public int filterCountByG_S(long groupId, int status) 1103 throws com.liferay.portal.kernel.exception.SystemException; 1104 1105 /** 1106 * Returns all the bookmarks entries where groupId = ? and userId = ? and status = ?. 1107 * 1108 * @param groupId the group ID 1109 * @param userId the user ID 1110 * @param status the status 1111 * @return the matching bookmarks entries 1112 * @throws SystemException if a system exception occurred 1113 */ 1114 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S( 1115 long groupId, long userId, int status) 1116 throws com.liferay.portal.kernel.exception.SystemException; 1117 1118 /** 1119 * Returns a range of all the bookmarks entries where groupId = ? and userId = ? and status = ?. 1120 * 1121 * <p> 1122 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1123 * </p> 1124 * 1125 * @param groupId the group ID 1126 * @param userId the user ID 1127 * @param status the status 1128 * @param start the lower bound of the range of bookmarks entries 1129 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1130 * @return the range of matching bookmarks entries 1131 * @throws SystemException if a system exception occurred 1132 */ 1133 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S( 1134 long groupId, long userId, int status, int start, int end) 1135 throws com.liferay.portal.kernel.exception.SystemException; 1136 1137 /** 1138 * Returns an ordered range of all the bookmarks entries where groupId = ? and userId = ? and status = ?. 1139 * 1140 * <p> 1141 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 1142 * </p> 1143 * 1144 * @param groupId the group ID 1145 * @param userId the user ID 1146 * @param status the status 1147 * @param start the lower bound of the range of bookmarks entries 1148 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1149 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1150 * @return the ordered range of matching bookmarks entries 1151 * @throws SystemException if a system exception occurred 1152 */ 1153 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_S( 1154 long groupId, long userId, int status, int start, int end, 1155 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1156 throws com.liferay.portal.kernel.exception.SystemException; 1157 1158 /** 1159 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ? and status = ?. 1160 * 1161 * @param groupId the group ID 1162 * @param userId the user ID 1163 * @param status the status 1164 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1165 * @return the first matching bookmarks entry 1166 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1167 * @throws SystemException if a system exception occurred 1168 */ 1169 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_S_First( 1170 long groupId, long userId, int status, 1171 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1172 throws com.liferay.portal.kernel.exception.SystemException, 1173 com.liferay.portlet.bookmarks.NoSuchEntryException; 1174 1175 /** 1176 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ? and status = ?. 1177 * 1178 * @param groupId the group ID 1179 * @param userId the user ID 1180 * @param status the status 1181 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1182 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1183 * @throws SystemException if a system exception occurred 1184 */ 1185 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_S_First( 1186 long groupId, long userId, int status, 1187 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1188 throws com.liferay.portal.kernel.exception.SystemException; 1189 1190 /** 1191 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ? and status = ?. 1192 * 1193 * @param groupId the group ID 1194 * @param userId the user ID 1195 * @param status the status 1196 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1197 * @return the last matching bookmarks entry 1198 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1199 * @throws SystemException if a system exception occurred 1200 */ 1201 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_S_Last( 1202 long groupId, long userId, int status, 1203 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1204 throws com.liferay.portal.kernel.exception.SystemException, 1205 com.liferay.portlet.bookmarks.NoSuchEntryException; 1206 1207 /** 1208 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ? and status = ?. 1209 * 1210 * @param groupId the group ID 1211 * @param userId the user ID 1212 * @param status the status 1213 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1214 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1215 * @throws SystemException if a system exception occurred 1216 */ 1217 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_S_Last( 1218 long groupId, long userId, int status, 1219 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1220 throws com.liferay.portal.kernel.exception.SystemException; 1221 1222 /** 1223 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and userId = ? and status = ?. 1224 * 1225 * @param entryId the primary key of the current bookmarks entry 1226 * @param groupId the group ID 1227 * @param userId the user ID 1228 * @param status the status 1229 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1230 * @return the previous, current, and next bookmarks entry 1231 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1232 * @throws SystemException if a system exception occurred 1233 */ 1234 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_U_S_PrevAndNext( 1235 long entryId, long groupId, long userId, int status, 1236 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1237 throws com.liferay.portal.kernel.exception.SystemException, 1238 com.liferay.portlet.bookmarks.NoSuchEntryException; 1239 1240 /** 1241 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and status = ?. 1242 * 1243 * @param groupId the group ID 1244 * @param userId the user ID 1245 * @param status the status 1246 * @return the matching bookmarks entries that the user has permission to view 1247 * @throws SystemException if a system exception occurred 1248 */ 1249 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S( 1250 long groupId, long userId, int status) 1251 throws com.liferay.portal.kernel.exception.SystemException; 1252 1253 /** 1254 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and status = ?. 1255 * 1256 * <p> 1257 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 1258 * </p> 1259 * 1260 * @param groupId the group ID 1261 * @param userId the user ID 1262 * @param status the status 1263 * @param start the lower bound of the range of bookmarks entries 1264 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1265 * @return the range of matching bookmarks entries that the user has permission to view 1266 * @throws SystemException if a system exception occurred 1267 */ 1268 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S( 1269 long groupId, long userId, int status, int start, int end) 1270 throws com.liferay.portal.kernel.exception.SystemException; 1271 1272 /** 1273 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and userId = ? and status = ?. 1274 * 1275 * <p> 1276 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 1277 * </p> 1278 * 1279 * @param groupId the group ID 1280 * @param userId the user ID 1281 * @param status the status 1282 * @param start the lower bound of the range of bookmarks entries 1283 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1284 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1285 * @return the ordered range of matching bookmarks entries that the user has permission to view 1286 * @throws SystemException if a system exception occurred 1287 */ 1288 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_S( 1289 long groupId, long userId, int status, int start, int end, 1290 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1291 throws com.liferay.portal.kernel.exception.SystemException; 1292 1293 /** 1294 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set of bookmarks entries that the user has permission to view where groupId = ? and userId = ? and status = ?. 1295 * 1296 * @param entryId the primary key of the current bookmarks entry 1297 * @param groupId the group ID 1298 * @param userId the user ID 1299 * @param status the status 1300 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1301 * @return the previous, current, and next bookmarks entry 1302 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1303 * @throws SystemException if a system exception occurred 1304 */ 1305 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_U_S_PrevAndNext( 1306 long entryId, long groupId, long userId, int status, 1307 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1308 throws com.liferay.portal.kernel.exception.SystemException, 1309 com.liferay.portlet.bookmarks.NoSuchEntryException; 1310 1311 /** 1312 * Removes all the bookmarks entries where groupId = ? and userId = ? and status = ? from the database. 1313 * 1314 * @param groupId the group ID 1315 * @param userId the user ID 1316 * @param status the status 1317 * @throws SystemException if a system exception occurred 1318 */ 1319 public void removeByG_U_S(long groupId, long userId, int status) 1320 throws com.liferay.portal.kernel.exception.SystemException; 1321 1322 /** 1323 * Returns the number of bookmarks entries where groupId = ? and userId = ? and status = ?. 1324 * 1325 * @param groupId the group ID 1326 * @param userId the user ID 1327 * @param status the status 1328 * @return the number of matching bookmarks entries 1329 * @throws SystemException if a system exception occurred 1330 */ 1331 public int countByG_U_S(long groupId, long userId, int status) 1332 throws com.liferay.portal.kernel.exception.SystemException; 1333 1334 /** 1335 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and userId = ? and status = ?. 1336 * 1337 * @param groupId the group ID 1338 * @param userId the user ID 1339 * @param status the status 1340 * @return the number of matching bookmarks entries that the user has permission to view 1341 * @throws SystemException if a system exception occurred 1342 */ 1343 public int filterCountByG_U_S(long groupId, long userId, int status) 1344 throws com.liferay.portal.kernel.exception.SystemException; 1345 1346 /** 1347 * Returns all the bookmarks entries where groupId = ? and folderId = ? and status = ?. 1348 * 1349 * @param groupId the group ID 1350 * @param folderId the folder ID 1351 * @param status the status 1352 * @return the matching bookmarks entries 1353 * @throws SystemException if a system exception occurred 1354 */ 1355 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 1356 long groupId, long folderId, int status) 1357 throws com.liferay.portal.kernel.exception.SystemException; 1358 1359 /** 1360 * Returns a range of all the bookmarks entries where groupId = ? and folderId = ? and status = ?. 1361 * 1362 * <p> 1363 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 1364 * </p> 1365 * 1366 * @param groupId the group ID 1367 * @param folderId the folder ID 1368 * @param status the status 1369 * @param start the lower bound of the range of bookmarks entries 1370 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1371 * @return the range of matching bookmarks entries 1372 * @throws SystemException if a system exception occurred 1373 */ 1374 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 1375 long groupId, long folderId, int status, int start, int end) 1376 throws com.liferay.portal.kernel.exception.SystemException; 1377 1378 /** 1379 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = ? and status = ?. 1380 * 1381 * <p> 1382 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 1383 * </p> 1384 * 1385 * @param groupId the group ID 1386 * @param folderId the folder ID 1387 * @param status the status 1388 * @param start the lower bound of the range of bookmarks entries 1389 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1390 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1391 * @return the ordered range of matching bookmarks entries 1392 * @throws SystemException if a system exception occurred 1393 */ 1394 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 1395 long groupId, long folderId, int status, int start, int end, 1396 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1397 throws com.liferay.portal.kernel.exception.SystemException; 1398 1399 /** 1400 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ? and status = ?. 1401 * 1402 * @param groupId the group ID 1403 * @param folderId the folder ID 1404 * @param status the status 1405 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1406 * @return the first matching bookmarks entry 1407 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1408 * @throws SystemException if a system exception occurred 1409 */ 1410 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_S_First( 1411 long groupId, long folderId, int status, 1412 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1413 throws com.liferay.portal.kernel.exception.SystemException, 1414 com.liferay.portlet.bookmarks.NoSuchEntryException; 1415 1416 /** 1417 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ? and status = ?. 1418 * 1419 * @param groupId the group ID 1420 * @param folderId the folder ID 1421 * @param status the status 1422 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1423 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1424 * @throws SystemException if a system exception occurred 1425 */ 1426 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_S_First( 1427 long groupId, long folderId, int status, 1428 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1429 throws com.liferay.portal.kernel.exception.SystemException; 1430 1431 /** 1432 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ? and status = ?. 1433 * 1434 * @param groupId the group ID 1435 * @param folderId the folder ID 1436 * @param status the status 1437 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1438 * @return the last matching bookmarks entry 1439 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1440 * @throws SystemException if a system exception occurred 1441 */ 1442 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_S_Last( 1443 long groupId, long folderId, int status, 1444 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1445 throws com.liferay.portal.kernel.exception.SystemException, 1446 com.liferay.portlet.bookmarks.NoSuchEntryException; 1447 1448 /** 1449 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ? and status = ?. 1450 * 1451 * @param groupId the group ID 1452 * @param folderId the folder ID 1453 * @param status the status 1454 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1455 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1456 * @throws SystemException if a system exception occurred 1457 */ 1458 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_S_Last( 1459 long groupId, long folderId, int status, 1460 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1461 throws com.liferay.portal.kernel.exception.SystemException; 1462 1463 /** 1464 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and folderId = ? and status = ?. 1465 * 1466 * @param entryId the primary key of the current bookmarks entry 1467 * @param groupId the group ID 1468 * @param folderId the folder ID 1469 * @param status the status 1470 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1471 * @return the previous, current, and next bookmarks entry 1472 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1473 * @throws SystemException if a system exception occurred 1474 */ 1475 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_S_PrevAndNext( 1476 long entryId, long groupId, long folderId, int status, 1477 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1478 throws com.liferay.portal.kernel.exception.SystemException, 1479 com.liferay.portlet.bookmarks.NoSuchEntryException; 1480 1481 /** 1482 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status = ?. 1483 * 1484 * @param groupId the group ID 1485 * @param folderId the folder ID 1486 * @param status the status 1487 * @return the matching bookmarks entries that the user has permission to view 1488 * @throws SystemException if a system exception occurred 1489 */ 1490 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 1491 long groupId, long folderId, int status) 1492 throws com.liferay.portal.kernel.exception.SystemException; 1493 1494 /** 1495 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status = ?. 1496 * 1497 * <p> 1498 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 1499 * </p> 1500 * 1501 * @param groupId the group ID 1502 * @param folderId the folder ID 1503 * @param status the status 1504 * @param start the lower bound of the range of bookmarks entries 1505 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1506 * @return the range of matching bookmarks entries that the user has permission to view 1507 * @throws SystemException if a system exception occurred 1508 */ 1509 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 1510 long groupId, long folderId, int status, int start, int end) 1511 throws com.liferay.portal.kernel.exception.SystemException; 1512 1513 /** 1514 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and folderId = ? and status = ?. 1515 * 1516 * <p> 1517 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 1518 * </p> 1519 * 1520 * @param groupId the group ID 1521 * @param folderId the folder ID 1522 * @param status the status 1523 * @param start the lower bound of the range of bookmarks entries 1524 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1525 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1526 * @return the ordered range of matching bookmarks entries that the user has permission to view 1527 * @throws SystemException if a system exception occurred 1528 */ 1529 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 1530 long groupId, long folderId, int status, int start, int end, 1531 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1532 throws com.liferay.portal.kernel.exception.SystemException; 1533 1534 /** 1535 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set of bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status = ?. 1536 * 1537 * @param entryId the primary key of the current bookmarks entry 1538 * @param groupId the group ID 1539 * @param folderId the folder ID 1540 * @param status the status 1541 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1542 * @return the previous, current, and next bookmarks entry 1543 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1544 * @throws SystemException if a system exception occurred 1545 */ 1546 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_S_PrevAndNext( 1547 long entryId, long groupId, long folderId, int status, 1548 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1549 throws com.liferay.portal.kernel.exception.SystemException, 1550 com.liferay.portlet.bookmarks.NoSuchEntryException; 1551 1552 /** 1553 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status = ?. 1554 * 1555 * @param groupId the group ID 1556 * @param folderIds the folder IDs 1557 * @param status the status 1558 * @return the matching bookmarks entries that the user has permission to view 1559 * @throws SystemException if a system exception occurred 1560 */ 1561 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 1562 long groupId, long[] folderIds, int status) 1563 throws com.liferay.portal.kernel.exception.SystemException; 1564 1565 /** 1566 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status = ?. 1567 * 1568 * <p> 1569 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 1570 * </p> 1571 * 1572 * @param groupId the group ID 1573 * @param folderIds the folder IDs 1574 * @param status the status 1575 * @param start the lower bound of the range of bookmarks entries 1576 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1577 * @return the range of matching bookmarks entries that the user has permission to view 1578 * @throws SystemException if a system exception occurred 1579 */ 1580 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 1581 long groupId, long[] folderIds, int status, int start, int end) 1582 throws com.liferay.portal.kernel.exception.SystemException; 1583 1584 /** 1585 * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status = ?. 1586 * 1587 * <p> 1588 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 1589 * </p> 1590 * 1591 * @param groupId the group ID 1592 * @param folderIds the folder IDs 1593 * @param status the status 1594 * @param start the lower bound of the range of bookmarks entries 1595 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1596 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1597 * @return the ordered range of matching bookmarks entries that the user has permission to view 1598 * @throws SystemException if a system exception occurred 1599 */ 1600 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F_S( 1601 long groupId, long[] folderIds, int status, int start, int end, 1602 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1603 throws com.liferay.portal.kernel.exception.SystemException; 1604 1605 /** 1606 * Returns all the bookmarks entries where groupId = ? and folderId = any ? and status = ?. 1607 * 1608 * <p> 1609 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 1610 * </p> 1611 * 1612 * @param groupId the group ID 1613 * @param folderIds the folder IDs 1614 * @param status the status 1615 * @return the matching bookmarks entries 1616 * @throws SystemException if a system exception occurred 1617 */ 1618 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 1619 long groupId, long[] folderIds, int status) 1620 throws com.liferay.portal.kernel.exception.SystemException; 1621 1622 /** 1623 * Returns a range of all the bookmarks entries where groupId = ? and folderId = any ? and status = ?. 1624 * 1625 * <p> 1626 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 1627 * </p> 1628 * 1629 * @param groupId the group ID 1630 * @param folderIds the folder IDs 1631 * @param status the status 1632 * @param start the lower bound of the range of bookmarks entries 1633 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1634 * @return the range of matching bookmarks entries 1635 * @throws SystemException if a system exception occurred 1636 */ 1637 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 1638 long groupId, long[] folderIds, int status, int start, int end) 1639 throws com.liferay.portal.kernel.exception.SystemException; 1640 1641 /** 1642 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = any ? and status = ?. 1643 * 1644 * <p> 1645 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 1646 * </p> 1647 * 1648 * @param groupId the group ID 1649 * @param folderIds the folder IDs 1650 * @param status the status 1651 * @param start the lower bound of the range of bookmarks entries 1652 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1653 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1654 * @return the ordered range of matching bookmarks entries 1655 * @throws SystemException if a system exception occurred 1656 */ 1657 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F_S( 1658 long groupId, long[] folderIds, int status, int start, int end, 1659 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1660 throws com.liferay.portal.kernel.exception.SystemException; 1661 1662 /** 1663 * Removes all the bookmarks entries where groupId = ? and folderId = ? and status = ? from the database. 1664 * 1665 * @param groupId the group ID 1666 * @param folderId the folder ID 1667 * @param status the status 1668 * @throws SystemException if a system exception occurred 1669 */ 1670 public void removeByG_F_S(long groupId, long folderId, int status) 1671 throws com.liferay.portal.kernel.exception.SystemException; 1672 1673 /** 1674 * Returns the number of bookmarks entries where groupId = ? and folderId = ? and status = ?. 1675 * 1676 * @param groupId the group ID 1677 * @param folderId the folder ID 1678 * @param status the status 1679 * @return the number of matching bookmarks entries 1680 * @throws SystemException if a system exception occurred 1681 */ 1682 public int countByG_F_S(long groupId, long folderId, int status) 1683 throws com.liferay.portal.kernel.exception.SystemException; 1684 1685 /** 1686 * Returns the number of bookmarks entries where groupId = ? and folderId = any ? and status = ?. 1687 * 1688 * @param groupId the group ID 1689 * @param folderIds the folder IDs 1690 * @param status the status 1691 * @return the number of matching bookmarks entries 1692 * @throws SystemException if a system exception occurred 1693 */ 1694 public int countByG_F_S(long groupId, long[] folderIds, int status) 1695 throws com.liferay.portal.kernel.exception.SystemException; 1696 1697 /** 1698 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = ? and status = ?. 1699 * 1700 * @param groupId the group ID 1701 * @param folderId the folder ID 1702 * @param status the status 1703 * @return the number of matching bookmarks entries that the user has permission to view 1704 * @throws SystemException if a system exception occurred 1705 */ 1706 public int filterCountByG_F_S(long groupId, long folderId, int status) 1707 throws com.liferay.portal.kernel.exception.SystemException; 1708 1709 /** 1710 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = any ? and status = ?. 1711 * 1712 * @param groupId the group ID 1713 * @param folderIds the folder IDs 1714 * @param status the status 1715 * @return the number of matching bookmarks entries that the user has permission to view 1716 * @throws SystemException if a system exception occurred 1717 */ 1718 public int filterCountByG_F_S(long groupId, long[] folderIds, int status) 1719 throws com.liferay.portal.kernel.exception.SystemException; 1720 1721 /** 1722 * Returns all the bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ?. 1723 * 1724 * @param groupId the group ID 1725 * @param userId the user ID 1726 * @param folderId the folder ID 1727 * @param status the status 1728 * @return the matching bookmarks entries 1729 * @throws SystemException if a system exception occurred 1730 */ 1731 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 1732 long groupId, long userId, long folderId, int status) 1733 throws com.liferay.portal.kernel.exception.SystemException; 1734 1735 /** 1736 * Returns a range of all the bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ?. 1737 * 1738 * <p> 1739 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 1740 * </p> 1741 * 1742 * @param groupId the group ID 1743 * @param userId the user ID 1744 * @param folderId the folder ID 1745 * @param status the status 1746 * @param start the lower bound of the range of bookmarks entries 1747 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1748 * @return the range of matching bookmarks entries 1749 * @throws SystemException if a system exception occurred 1750 */ 1751 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 1752 long groupId, long userId, long folderId, int status, int start, int end) 1753 throws com.liferay.portal.kernel.exception.SystemException; 1754 1755 /** 1756 * Returns an ordered range of all the bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ?. 1757 * 1758 * <p> 1759 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 1760 * </p> 1761 * 1762 * @param groupId the group ID 1763 * @param userId the user ID 1764 * @param folderId the folder ID 1765 * @param status the status 1766 * @param start the lower bound of the range of bookmarks entries 1767 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1768 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1769 * @return the ordered range of matching bookmarks entries 1770 * @throws SystemException if a system exception occurred 1771 */ 1772 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 1773 long groupId, long userId, long folderId, int status, int start, 1774 int end, 1775 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1776 throws com.liferay.portal.kernel.exception.SystemException; 1777 1778 /** 1779 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 1780 * 1781 * @param groupId the group ID 1782 * @param userId the user ID 1783 * @param folderId the folder ID 1784 * @param status the status 1785 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1786 * @return the first matching bookmarks entry 1787 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1788 * @throws SystemException if a system exception occurred 1789 */ 1790 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_F_S_First( 1791 long groupId, long userId, long folderId, int status, 1792 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1793 throws com.liferay.portal.kernel.exception.SystemException, 1794 com.liferay.portlet.bookmarks.NoSuchEntryException; 1795 1796 /** 1797 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 1798 * 1799 * @param groupId the group ID 1800 * @param userId the user ID 1801 * @param folderId the folder ID 1802 * @param status the status 1803 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1804 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1805 * @throws SystemException if a system exception occurred 1806 */ 1807 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_F_S_First( 1808 long groupId, long userId, long folderId, int status, 1809 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1810 throws com.liferay.portal.kernel.exception.SystemException; 1811 1812 /** 1813 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 1814 * 1815 * @param groupId the group ID 1816 * @param userId the user ID 1817 * @param folderId the folder ID 1818 * @param status the status 1819 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1820 * @return the last matching bookmarks entry 1821 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1822 * @throws SystemException if a system exception occurred 1823 */ 1824 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_F_S_Last( 1825 long groupId, long userId, long folderId, int status, 1826 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1827 throws com.liferay.portal.kernel.exception.SystemException, 1828 com.liferay.portlet.bookmarks.NoSuchEntryException; 1829 1830 /** 1831 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 1832 * 1833 * @param groupId the group ID 1834 * @param userId the user ID 1835 * @param folderId the folder ID 1836 * @param status the status 1837 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1838 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1839 * @throws SystemException if a system exception occurred 1840 */ 1841 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_F_S_Last( 1842 long groupId, long userId, long folderId, int status, 1843 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1844 throws com.liferay.portal.kernel.exception.SystemException; 1845 1846 /** 1847 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and userId = ? and folderId = ? and status = ?. 1848 * 1849 * @param entryId the primary key of the current bookmarks entry 1850 * @param groupId the group ID 1851 * @param userId the user ID 1852 * @param folderId the folder ID 1853 * @param status the status 1854 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1855 * @return the previous, current, and next bookmarks entry 1856 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1857 * @throws SystemException if a system exception occurred 1858 */ 1859 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_U_F_S_PrevAndNext( 1860 long entryId, long groupId, long userId, long folderId, int status, 1861 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1862 throws com.liferay.portal.kernel.exception.SystemException, 1863 com.liferay.portlet.bookmarks.NoSuchEntryException; 1864 1865 /** 1866 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = ? and status = ?. 1867 * 1868 * @param groupId the group ID 1869 * @param userId the user ID 1870 * @param folderId the folder ID 1871 * @param status the status 1872 * @return the matching bookmarks entries that the user has permission to view 1873 * @throws SystemException if a system exception occurred 1874 */ 1875 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 1876 long groupId, long userId, long folderId, int status) 1877 throws com.liferay.portal.kernel.exception.SystemException; 1878 1879 /** 1880 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = ? and status = ?. 1881 * 1882 * <p> 1883 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 1884 * </p> 1885 * 1886 * @param groupId the group ID 1887 * @param userId the user ID 1888 * @param folderId the folder ID 1889 * @param status the status 1890 * @param start the lower bound of the range of bookmarks entries 1891 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1892 * @return the range of matching bookmarks entries that the user has permission to view 1893 * @throws SystemException if a system exception occurred 1894 */ 1895 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 1896 long groupId, long userId, long folderId, int status, int start, int end) 1897 throws com.liferay.portal.kernel.exception.SystemException; 1898 1899 /** 1900 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and userId = ? and folderId = ? and status = ?. 1901 * 1902 * <p> 1903 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 1904 * </p> 1905 * 1906 * @param groupId the group ID 1907 * @param userId the user ID 1908 * @param folderId the folder ID 1909 * @param status the status 1910 * @param start the lower bound of the range of bookmarks entries 1911 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1912 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1913 * @return the ordered range of matching bookmarks entries that the user has permission to view 1914 * @throws SystemException if a system exception occurred 1915 */ 1916 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 1917 long groupId, long userId, long folderId, int status, int start, 1918 int end, 1919 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1920 throws com.liferay.portal.kernel.exception.SystemException; 1921 1922 /** 1923 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set of bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = ? and status = ?. 1924 * 1925 * @param entryId the primary key of the current bookmarks entry 1926 * @param groupId the group ID 1927 * @param userId the user ID 1928 * @param folderId the folder ID 1929 * @param status the status 1930 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1931 * @return the previous, current, and next bookmarks entry 1932 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1933 * @throws SystemException if a system exception occurred 1934 */ 1935 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_U_F_S_PrevAndNext( 1936 long entryId, long groupId, long userId, long folderId, int status, 1937 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1938 throws com.liferay.portal.kernel.exception.SystemException, 1939 com.liferay.portlet.bookmarks.NoSuchEntryException; 1940 1941 /** 1942 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ? and status = ?. 1943 * 1944 * @param groupId the group ID 1945 * @param userId the user ID 1946 * @param folderIds the folder IDs 1947 * @param status the status 1948 * @return the matching bookmarks entries that the user has permission to view 1949 * @throws SystemException if a system exception occurred 1950 */ 1951 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 1952 long groupId, long userId, long[] folderIds, int status) 1953 throws com.liferay.portal.kernel.exception.SystemException; 1954 1955 /** 1956 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ? and status = ?. 1957 * 1958 * <p> 1959 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 1960 * </p> 1961 * 1962 * @param groupId the group ID 1963 * @param userId the user ID 1964 * @param folderIds the folder IDs 1965 * @param status the status 1966 * @param start the lower bound of the range of bookmarks entries 1967 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1968 * @return the range of matching bookmarks entries that the user has permission to view 1969 * @throws SystemException if a system exception occurred 1970 */ 1971 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 1972 long groupId, long userId, long[] folderIds, int status, int start, 1973 int end) throws com.liferay.portal.kernel.exception.SystemException; 1974 1975 /** 1976 * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ? and status = ?. 1977 * 1978 * <p> 1979 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 1980 * </p> 1981 * 1982 * @param groupId the group ID 1983 * @param userId the user ID 1984 * @param folderIds the folder IDs 1985 * @param status the status 1986 * @param start the lower bound of the range of bookmarks entries 1987 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1988 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1989 * @return the ordered range of matching bookmarks entries that the user has permission to view 1990 * @throws SystemException if a system exception occurred 1991 */ 1992 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U_F_S( 1993 long groupId, long userId, long[] folderIds, int status, int start, 1994 int end, 1995 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1996 throws com.liferay.portal.kernel.exception.SystemException; 1997 1998 /** 1999 * Returns all the bookmarks entries where groupId = ? and userId = ? and folderId = any ? and status = ?. 2000 * 2001 * <p> 2002 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 2003 * </p> 2004 * 2005 * @param groupId the group ID 2006 * @param userId the user ID 2007 * @param folderIds the folder IDs 2008 * @param status the status 2009 * @return the matching bookmarks entries 2010 * @throws SystemException if a system exception occurred 2011 */ 2012 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 2013 long groupId, long userId, long[] folderIds, int status) 2014 throws com.liferay.portal.kernel.exception.SystemException; 2015 2016 /** 2017 * Returns a range of all the bookmarks entries where groupId = ? and userId = ? and folderId = any ? and status = ?. 2018 * 2019 * <p> 2020 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 2021 * </p> 2022 * 2023 * @param groupId the group ID 2024 * @param userId the user ID 2025 * @param folderIds the folder IDs 2026 * @param status the status 2027 * @param start the lower bound of the range of bookmarks entries 2028 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2029 * @return the range of matching bookmarks entries 2030 * @throws SystemException if a system exception occurred 2031 */ 2032 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 2033 long groupId, long userId, long[] folderIds, int status, int start, 2034 int end) throws com.liferay.portal.kernel.exception.SystemException; 2035 2036 /** 2037 * Returns an ordered range of all the bookmarks entries where groupId = ? and userId = ? and folderId = any ? and status = ?. 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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 groupId the group ID 2044 * @param userId the user ID 2045 * @param folderIds the folder IDs 2046 * @param status the status 2047 * @param start the lower bound of the range of bookmarks entries 2048 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2049 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2050 * @return the ordered range of matching bookmarks entries 2051 * @throws SystemException if a system exception occurred 2052 */ 2053 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U_F_S( 2054 long groupId, long userId, long[] folderIds, int status, int start, 2055 int end, 2056 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2057 throws com.liferay.portal.kernel.exception.SystemException; 2058 2059 /** 2060 * Removes all the bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ? from the database. 2061 * 2062 * @param groupId the group ID 2063 * @param userId the user ID 2064 * @param folderId the folder ID 2065 * @param status the status 2066 * @throws SystemException if a system exception occurred 2067 */ 2068 public void removeByG_U_F_S(long groupId, long userId, long folderId, 2069 int status) throws com.liferay.portal.kernel.exception.SystemException; 2070 2071 /** 2072 * Returns the number of bookmarks entries where groupId = ? and userId = ? and folderId = ? and status = ?. 2073 * 2074 * @param groupId the group ID 2075 * @param userId the user ID 2076 * @param folderId the folder ID 2077 * @param status the status 2078 * @return the number of matching bookmarks entries 2079 * @throws SystemException if a system exception occurred 2080 */ 2081 public int countByG_U_F_S(long groupId, long userId, long folderId, 2082 int status) throws com.liferay.portal.kernel.exception.SystemException; 2083 2084 /** 2085 * Returns the number of bookmarks entries where groupId = ? and userId = ? and folderId = any ? and status = ?. 2086 * 2087 * @param groupId the group ID 2088 * @param userId the user ID 2089 * @param folderIds the folder IDs 2090 * @param status the status 2091 * @return the number of matching bookmarks entries 2092 * @throws SystemException if a system exception occurred 2093 */ 2094 public int countByG_U_F_S(long groupId, long userId, long[] folderIds, 2095 int status) throws com.liferay.portal.kernel.exception.SystemException; 2096 2097 /** 2098 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = ? and status = ?. 2099 * 2100 * @param groupId the group ID 2101 * @param userId the user ID 2102 * @param folderId the folder ID 2103 * @param status the status 2104 * @return the number of matching bookmarks entries that the user has permission to view 2105 * @throws SystemException if a system exception occurred 2106 */ 2107 public int filterCountByG_U_F_S(long groupId, long userId, long folderId, 2108 int status) throws com.liferay.portal.kernel.exception.SystemException; 2109 2110 /** 2111 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and userId = ? and folderId = any ? and status = ?. 2112 * 2113 * @param groupId the group ID 2114 * @param userId the user ID 2115 * @param folderIds the folder IDs 2116 * @param status the status 2117 * @return the number of matching bookmarks entries that the user has permission to view 2118 * @throws SystemException if a system exception occurred 2119 */ 2120 public int filterCountByG_U_F_S(long groupId, long userId, 2121 long[] folderIds, int status) 2122 throws com.liferay.portal.kernel.exception.SystemException; 2123 2124 /** 2125 * Caches the bookmarks entry in the entity cache if it is enabled. 2126 * 2127 * @param bookmarksEntry the bookmarks entry 2128 */ 2129 public void cacheResult( 2130 com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry); 2131 2132 /** 2133 * Caches the bookmarks entries in the entity cache if it is enabled. 2134 * 2135 * @param bookmarksEntries the bookmarks entries 2136 */ 2137 public void cacheResult( 2138 java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> bookmarksEntries); 2139 2140 /** 2141 * Creates a new bookmarks entry with the primary key. Does not add the bookmarks entry to the database. 2142 * 2143 * @param entryId the primary key for the new bookmarks entry 2144 * @return the new bookmarks entry 2145 */ 2146 public com.liferay.portlet.bookmarks.model.BookmarksEntry create( 2147 long entryId); 2148 2149 /** 2150 * Removes the bookmarks entry with the primary key from the database. Also notifies the appropriate model listeners. 2151 * 2152 * @param entryId the primary key of the bookmarks entry 2153 * @return the bookmarks entry that was removed 2154 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 2155 * @throws SystemException if a system exception occurred 2156 */ 2157 public com.liferay.portlet.bookmarks.model.BookmarksEntry remove( 2158 long entryId) 2159 throws com.liferay.portal.kernel.exception.SystemException, 2160 com.liferay.portlet.bookmarks.NoSuchEntryException; 2161 2162 public com.liferay.portlet.bookmarks.model.BookmarksEntry updateImpl( 2163 com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry) 2164 throws com.liferay.portal.kernel.exception.SystemException; 2165 2166 /** 2167 * Returns the bookmarks entry with the primary key or throws a {@link com.liferay.portlet.bookmarks.NoSuchEntryException} if it could not be found. 2168 * 2169 * @param entryId the primary key of the bookmarks entry 2170 * @return the bookmarks entry 2171 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 2172 * @throws SystemException if a system exception occurred 2173 */ 2174 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByPrimaryKey( 2175 long entryId) 2176 throws com.liferay.portal.kernel.exception.SystemException, 2177 com.liferay.portlet.bookmarks.NoSuchEntryException; 2178 2179 /** 2180 * Returns the bookmarks entry with the primary key or returns <code>null</code> if it could not be found. 2181 * 2182 * @param entryId the primary key of the bookmarks entry 2183 * @return the bookmarks entry, or <code>null</code> if a bookmarks entry with the primary key could not be found 2184 * @throws SystemException if a system exception occurred 2185 */ 2186 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByPrimaryKey( 2187 long entryId) 2188 throws com.liferay.portal.kernel.exception.SystemException; 2189 2190 /** 2191 * Returns all the bookmarks entries. 2192 * 2193 * @return the bookmarks entries 2194 * @throws SystemException if a system exception occurred 2195 */ 2196 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll() 2197 throws com.liferay.portal.kernel.exception.SystemException; 2198 2199 /** 2200 * Returns a range of all the bookmarks entries. 2201 * 2202 * <p> 2203 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 2204 * </p> 2205 * 2206 * @param start the lower bound of the range of bookmarks entries 2207 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2208 * @return the range of bookmarks entries 2209 * @throws SystemException if a system exception occurred 2210 */ 2211 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll( 2212 int start, int end) 2213 throws com.liferay.portal.kernel.exception.SystemException; 2214 2215 /** 2216 * Returns an ordered range of all the bookmarks entries. 2217 * 2218 * <p> 2219 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksEntryModelImpl}. 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. 2220 * </p> 2221 * 2222 * @param start the lower bound of the range of bookmarks entries 2223 * @param end the upper bound of the range of bookmarks entries (not inclusive) 2224 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2225 * @return the ordered range of bookmarks entries 2226 * @throws SystemException if a system exception occurred 2227 */ 2228 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll( 2229 int start, int end, 2230 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2231 throws com.liferay.portal.kernel.exception.SystemException; 2232 2233 /** 2234 * Removes all the bookmarks entries from the database. 2235 * 2236 * @throws SystemException if a system exception occurred 2237 */ 2238 public void removeAll() 2239 throws com.liferay.portal.kernel.exception.SystemException; 2240 2241 /** 2242 * Returns the number of bookmarks entries. 2243 * 2244 * @return the number of bookmarks entries 2245 * @throws SystemException if a system exception occurred 2246 */ 2247 public int countAll() 2248 throws com.liferay.portal.kernel.exception.SystemException; 2249 }