001 /** 002 * Copyright (c) 2000-2012 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 = ?. 529 * 530 * @param groupId the group ID 531 * @return the matching bookmarks entries 532 * @throws SystemException if a system exception occurred 533 */ 534 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByGroupId( 535 long groupId) 536 throws com.liferay.portal.kernel.exception.SystemException; 537 538 /** 539 * Returns a range of all the bookmarks entries where groupId = ?. 540 * 541 * <p> 542 * 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. 543 * </p> 544 * 545 * @param groupId the group ID 546 * @param start the lower bound of the range of bookmarks entries 547 * @param end the upper bound of the range of bookmarks entries (not inclusive) 548 * @return the range of matching bookmarks entries 549 * @throws SystemException if a system exception occurred 550 */ 551 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByGroupId( 552 long groupId, int start, int end) 553 throws com.liferay.portal.kernel.exception.SystemException; 554 555 /** 556 * Returns an ordered range of all the bookmarks entries where groupId = ?. 557 * 558 * <p> 559 * 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. 560 * </p> 561 * 562 * @param groupId the group ID 563 * @param start the lower bound of the range of bookmarks entries 564 * @param end the upper bound of the range of bookmarks entries (not inclusive) 565 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 566 * @return the ordered range of matching bookmarks entries 567 * @throws SystemException if a system exception occurred 568 */ 569 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByGroupId( 570 long groupId, int start, int end, 571 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 572 throws com.liferay.portal.kernel.exception.SystemException; 573 574 /** 575 * Returns the first bookmarks entry in the ordered set where groupId = ?. 576 * 577 * @param groupId the group ID 578 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 579 * @return the first matching bookmarks entry 580 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 581 * @throws SystemException if a system exception occurred 582 */ 583 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByGroupId_First( 584 long groupId, 585 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 586 throws com.liferay.portal.kernel.exception.SystemException, 587 com.liferay.portlet.bookmarks.NoSuchEntryException; 588 589 /** 590 * Returns the first bookmarks entry in the ordered set where groupId = ?. 591 * 592 * @param groupId the group ID 593 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 594 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 595 * @throws SystemException if a system exception occurred 596 */ 597 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByGroupId_First( 598 long groupId, 599 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 600 throws com.liferay.portal.kernel.exception.SystemException; 601 602 /** 603 * Returns the last bookmarks entry in the ordered set where groupId = ?. 604 * 605 * @param groupId the group ID 606 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 607 * @return the last matching bookmarks entry 608 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 609 * @throws SystemException if a system exception occurred 610 */ 611 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByGroupId_Last( 612 long groupId, 613 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 614 throws com.liferay.portal.kernel.exception.SystemException, 615 com.liferay.portlet.bookmarks.NoSuchEntryException; 616 617 /** 618 * Returns the last bookmarks entry in the ordered set where groupId = ?. 619 * 620 * @param groupId the group ID 621 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 622 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 623 * @throws SystemException if a system exception occurred 624 */ 625 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByGroupId_Last( 626 long groupId, 627 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 628 throws com.liferay.portal.kernel.exception.SystemException; 629 630 /** 631 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ?. 632 * 633 * @param entryId the primary key of the current bookmarks entry 634 * @param groupId the group ID 635 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 636 * @return the previous, current, and next bookmarks entry 637 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 638 * @throws SystemException if a system exception occurred 639 */ 640 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByGroupId_PrevAndNext( 641 long entryId, long groupId, 642 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 643 throws com.liferay.portal.kernel.exception.SystemException, 644 com.liferay.portlet.bookmarks.NoSuchEntryException; 645 646 /** 647 * Returns all the bookmarks entries that the user has permission to view where groupId = ?. 648 * 649 * @param groupId the group ID 650 * @return the matching bookmarks entries that the user has permission to view 651 * @throws SystemException if a system exception occurred 652 */ 653 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByGroupId( 654 long groupId) 655 throws com.liferay.portal.kernel.exception.SystemException; 656 657 /** 658 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ?. 659 * 660 * <p> 661 * 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. 662 * </p> 663 * 664 * @param groupId the group ID 665 * @param start the lower bound of the range of bookmarks entries 666 * @param end the upper bound of the range of bookmarks entries (not inclusive) 667 * @return the range of matching bookmarks entries that the user has permission to view 668 * @throws SystemException if a system exception occurred 669 */ 670 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByGroupId( 671 long groupId, int start, int end) 672 throws com.liferay.portal.kernel.exception.SystemException; 673 674 /** 675 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ?. 676 * 677 * <p> 678 * 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. 679 * </p> 680 * 681 * @param groupId the group ID 682 * @param start the lower bound of the range of bookmarks entries 683 * @param end the upper bound of the range of bookmarks entries (not inclusive) 684 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 685 * @return the ordered range of matching bookmarks entries that the user has permission to view 686 * @throws SystemException if a system exception occurred 687 */ 688 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByGroupId( 689 long groupId, int start, int end, 690 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 691 throws com.liferay.portal.kernel.exception.SystemException; 692 693 /** 694 * 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 = ?. 695 * 696 * @param entryId the primary key of the current bookmarks entry 697 * @param groupId the group ID 698 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 699 * @return the previous, current, and next bookmarks entry 700 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 701 * @throws SystemException if a system exception occurred 702 */ 703 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByGroupId_PrevAndNext( 704 long entryId, long groupId, 705 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 706 throws com.liferay.portal.kernel.exception.SystemException, 707 com.liferay.portlet.bookmarks.NoSuchEntryException; 708 709 /** 710 * Removes all the bookmarks entries where groupId = ? from the database. 711 * 712 * @param groupId the group ID 713 * @throws SystemException if a system exception occurred 714 */ 715 public void removeByGroupId(long groupId) 716 throws com.liferay.portal.kernel.exception.SystemException; 717 718 /** 719 * Returns the number of bookmarks entries where groupId = ?. 720 * 721 * @param groupId the group ID 722 * @return the number of matching bookmarks entries 723 * @throws SystemException if a system exception occurred 724 */ 725 public int countByGroupId(long groupId) 726 throws com.liferay.portal.kernel.exception.SystemException; 727 728 /** 729 * Returns the number of bookmarks entries that the user has permission to view where groupId = ?. 730 * 731 * @param groupId the group ID 732 * @return the number of matching bookmarks entries that the user has permission to view 733 * @throws SystemException if a system exception occurred 734 */ 735 public int filterCountByGroupId(long groupId) 736 throws com.liferay.portal.kernel.exception.SystemException; 737 738 /** 739 * Returns all the bookmarks entries where groupId = ? and userId = ?. 740 * 741 * @param groupId the group ID 742 * @param userId the user ID 743 * @return the matching bookmarks entries 744 * @throws SystemException if a system exception occurred 745 */ 746 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U( 747 long groupId, long userId) 748 throws com.liferay.portal.kernel.exception.SystemException; 749 750 /** 751 * Returns a range of all the bookmarks entries where groupId = ? and userId = ?. 752 * 753 * <p> 754 * 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. 755 * </p> 756 * 757 * @param groupId the group ID 758 * @param userId the user ID 759 * @param start the lower bound of the range of bookmarks entries 760 * @param end the upper bound of the range of bookmarks entries (not inclusive) 761 * @return the range of matching bookmarks entries 762 * @throws SystemException if a system exception occurred 763 */ 764 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U( 765 long groupId, long userId, int start, int end) 766 throws com.liferay.portal.kernel.exception.SystemException; 767 768 /** 769 * Returns an ordered range of all the bookmarks entries where groupId = ? and userId = ?. 770 * 771 * <p> 772 * 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. 773 * </p> 774 * 775 * @param groupId the group ID 776 * @param userId the user ID 777 * @param start the lower bound of the range of bookmarks entries 778 * @param end the upper bound of the range of bookmarks entries (not inclusive) 779 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 780 * @return the ordered range of matching bookmarks entries 781 * @throws SystemException if a system exception occurred 782 */ 783 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_U( 784 long groupId, long userId, int start, int end, 785 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 786 throws com.liferay.portal.kernel.exception.SystemException; 787 788 /** 789 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ?. 790 * 791 * @param groupId the group ID 792 * @param userId the user ID 793 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 794 * @return the first matching bookmarks entry 795 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 796 * @throws SystemException if a system exception occurred 797 */ 798 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_First( 799 long groupId, long userId, 800 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 801 throws com.liferay.portal.kernel.exception.SystemException, 802 com.liferay.portlet.bookmarks.NoSuchEntryException; 803 804 /** 805 * Returns the first bookmarks entry in the ordered set where groupId = ? and userId = ?. 806 * 807 * @param groupId the group ID 808 * @param userId the user ID 809 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 810 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 811 * @throws SystemException if a system exception occurred 812 */ 813 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_First( 814 long groupId, long userId, 815 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 816 throws com.liferay.portal.kernel.exception.SystemException; 817 818 /** 819 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ?. 820 * 821 * @param groupId the group ID 822 * @param userId the user ID 823 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 824 * @return the last matching bookmarks entry 825 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 826 * @throws SystemException if a system exception occurred 827 */ 828 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_U_Last( 829 long groupId, long userId, 830 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 831 throws com.liferay.portal.kernel.exception.SystemException, 832 com.liferay.portlet.bookmarks.NoSuchEntryException; 833 834 /** 835 * Returns the last bookmarks entry in the ordered set where groupId = ? and userId = ?. 836 * 837 * @param groupId the group ID 838 * @param userId the user ID 839 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 840 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 841 * @throws SystemException if a system exception occurred 842 */ 843 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_U_Last( 844 long groupId, long userId, 845 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 846 throws com.liferay.portal.kernel.exception.SystemException; 847 848 /** 849 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and userId = ?. 850 * 851 * @param entryId the primary key of the current bookmarks entry 852 * @param groupId the group ID 853 * @param userId the user ID 854 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 855 * @return the previous, current, and next bookmarks entry 856 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 857 * @throws SystemException if a system exception occurred 858 */ 859 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_U_PrevAndNext( 860 long entryId, long groupId, long userId, 861 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 862 throws com.liferay.portal.kernel.exception.SystemException, 863 com.liferay.portlet.bookmarks.NoSuchEntryException; 864 865 /** 866 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and userId = ?. 867 * 868 * @param groupId the group ID 869 * @param userId the user ID 870 * @return the matching bookmarks entries that the user has permission to view 871 * @throws SystemException if a system exception occurred 872 */ 873 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U( 874 long groupId, long userId) 875 throws com.liferay.portal.kernel.exception.SystemException; 876 877 /** 878 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and userId = ?. 879 * 880 * <p> 881 * 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. 882 * </p> 883 * 884 * @param groupId the group ID 885 * @param userId the user ID 886 * @param start the lower bound of the range of bookmarks entries 887 * @param end the upper bound of the range of bookmarks entries (not inclusive) 888 * @return the range of matching bookmarks entries that the user has permission to view 889 * @throws SystemException if a system exception occurred 890 */ 891 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U( 892 long groupId, long userId, int start, int end) 893 throws com.liferay.portal.kernel.exception.SystemException; 894 895 /** 896 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and userId = ?. 897 * 898 * <p> 899 * 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. 900 * </p> 901 * 902 * @param groupId the group ID 903 * @param userId the user ID 904 * @param start the lower bound of the range of bookmarks entries 905 * @param end the upper bound of the range of bookmarks entries (not inclusive) 906 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 907 * @return the ordered range of matching bookmarks entries that the user has permission to view 908 * @throws SystemException if a system exception occurred 909 */ 910 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_U( 911 long groupId, long userId, int start, int end, 912 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 913 throws com.liferay.portal.kernel.exception.SystemException; 914 915 /** 916 * 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 = ?. 917 * 918 * @param entryId the primary key of the current bookmarks entry 919 * @param groupId the group ID 920 * @param userId the user ID 921 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 922 * @return the previous, current, and next bookmarks entry 923 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 924 * @throws SystemException if a system exception occurred 925 */ 926 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_U_PrevAndNext( 927 long entryId, long groupId, long userId, 928 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 929 throws com.liferay.portal.kernel.exception.SystemException, 930 com.liferay.portlet.bookmarks.NoSuchEntryException; 931 932 /** 933 * Removes all the bookmarks entries where groupId = ? and userId = ? from the database. 934 * 935 * @param groupId the group ID 936 * @param userId the user ID 937 * @throws SystemException if a system exception occurred 938 */ 939 public void removeByG_U(long groupId, long userId) 940 throws com.liferay.portal.kernel.exception.SystemException; 941 942 /** 943 * Returns the number of bookmarks entries where groupId = ? and userId = ?. 944 * 945 * @param groupId the group ID 946 * @param userId the user ID 947 * @return the number of matching bookmarks entries 948 * @throws SystemException if a system exception occurred 949 */ 950 public int countByG_U(long groupId, long userId) 951 throws com.liferay.portal.kernel.exception.SystemException; 952 953 /** 954 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and userId = ?. 955 * 956 * @param groupId the group ID 957 * @param userId the user ID 958 * @return the number of matching bookmarks entries that the user has permission to view 959 * @throws SystemException if a system exception occurred 960 */ 961 public int filterCountByG_U(long groupId, long userId) 962 throws com.liferay.portal.kernel.exception.SystemException; 963 964 /** 965 * Returns all the bookmarks entries where groupId = ? and folderId = ?. 966 * 967 * @param groupId the group ID 968 * @param folderId the folder ID 969 * @return the matching bookmarks entries 970 * @throws SystemException if a system exception occurred 971 */ 972 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 973 long groupId, long folderId) 974 throws com.liferay.portal.kernel.exception.SystemException; 975 976 /** 977 * Returns a range of all the bookmarks entries where groupId = ? and folderId = ?. 978 * 979 * <p> 980 * 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. 981 * </p> 982 * 983 * @param groupId the group ID 984 * @param folderId the folder ID 985 * @param start the lower bound of the range of bookmarks entries 986 * @param end the upper bound of the range of bookmarks entries (not inclusive) 987 * @return the range of matching bookmarks entries 988 * @throws SystemException if a system exception occurred 989 */ 990 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 991 long groupId, long folderId, int start, int end) 992 throws com.liferay.portal.kernel.exception.SystemException; 993 994 /** 995 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = ?. 996 * 997 * <p> 998 * 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. 999 * </p> 1000 * 1001 * @param groupId the group ID 1002 * @param folderId the folder ID 1003 * @param start the lower bound of the range of bookmarks entries 1004 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1005 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1006 * @return the ordered range of matching bookmarks entries 1007 * @throws SystemException if a system exception occurred 1008 */ 1009 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 1010 long groupId, long folderId, int start, int end, 1011 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1012 throws com.liferay.portal.kernel.exception.SystemException; 1013 1014 /** 1015 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ?. 1016 * 1017 * @param groupId the group ID 1018 * @param folderId the folder ID 1019 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1020 * @return the first matching bookmarks entry 1021 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1022 * @throws SystemException if a system exception occurred 1023 */ 1024 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_First( 1025 long groupId, long folderId, 1026 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1027 throws com.liferay.portal.kernel.exception.SystemException, 1028 com.liferay.portlet.bookmarks.NoSuchEntryException; 1029 1030 /** 1031 * Returns the first bookmarks entry in the ordered set where groupId = ? and folderId = ?. 1032 * 1033 * @param groupId the group ID 1034 * @param folderId the folder ID 1035 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1036 * @return the first matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1037 * @throws SystemException if a system exception occurred 1038 */ 1039 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_First( 1040 long groupId, long folderId, 1041 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1042 throws com.liferay.portal.kernel.exception.SystemException; 1043 1044 /** 1045 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ?. 1046 * 1047 * @param groupId the group ID 1048 * @param folderId the folder ID 1049 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1050 * @return the last matching bookmarks entry 1051 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a matching bookmarks entry could not be found 1052 * @throws SystemException if a system exception occurred 1053 */ 1054 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByG_F_Last( 1055 long groupId, long folderId, 1056 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1057 throws com.liferay.portal.kernel.exception.SystemException, 1058 com.liferay.portlet.bookmarks.NoSuchEntryException; 1059 1060 /** 1061 * Returns the last bookmarks entry in the ordered set where groupId = ? and folderId = ?. 1062 * 1063 * @param groupId the group ID 1064 * @param folderId the folder ID 1065 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1066 * @return the last matching bookmarks entry, or <code>null</code> if a matching bookmarks entry could not be found 1067 * @throws SystemException if a system exception occurred 1068 */ 1069 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByG_F_Last( 1070 long groupId, long folderId, 1071 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1072 throws com.liferay.portal.kernel.exception.SystemException; 1073 1074 /** 1075 * Returns the bookmarks entries before and after the current bookmarks entry in the ordered set where groupId = ? and folderId = ?. 1076 * 1077 * @param entryId the primary key of the current bookmarks entry 1078 * @param groupId the group ID 1079 * @param folderId the folder ID 1080 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1081 * @return the previous, current, and next bookmarks entry 1082 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1083 * @throws SystemException if a system exception occurred 1084 */ 1085 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] findByG_F_PrevAndNext( 1086 long entryId, long groupId, long folderId, 1087 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1088 throws com.liferay.portal.kernel.exception.SystemException, 1089 com.liferay.portlet.bookmarks.NoSuchEntryException; 1090 1091 /** 1092 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ?. 1093 * 1094 * @param groupId the group ID 1095 * @param folderId the folder ID 1096 * @return the matching bookmarks entries that the user has permission to view 1097 * @throws SystemException if a system exception occurred 1098 */ 1099 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 1100 long groupId, long folderId) 1101 throws com.liferay.portal.kernel.exception.SystemException; 1102 1103 /** 1104 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = ?. 1105 * 1106 * <p> 1107 * 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. 1108 * </p> 1109 * 1110 * @param groupId the group ID 1111 * @param folderId the folder ID 1112 * @param start the lower bound of the range of bookmarks entries 1113 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1114 * @return the range of matching bookmarks entries that the user has permission to view 1115 * @throws SystemException if a system exception occurred 1116 */ 1117 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 1118 long groupId, long folderId, int start, int end) 1119 throws com.liferay.portal.kernel.exception.SystemException; 1120 1121 /** 1122 * Returns an ordered range of all the bookmarks entries that the user has permissions to view where groupId = ? and folderId = ?. 1123 * 1124 * <p> 1125 * 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. 1126 * </p> 1127 * 1128 * @param groupId the group ID 1129 * @param folderId the folder ID 1130 * @param start the lower bound of the range of bookmarks entries 1131 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1132 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1133 * @return the ordered range of matching bookmarks entries that the user has permission to view 1134 * @throws SystemException if a system exception occurred 1135 */ 1136 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 1137 long groupId, long folderId, int start, int end, 1138 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1139 throws com.liferay.portal.kernel.exception.SystemException; 1140 1141 /** 1142 * 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 = ?. 1143 * 1144 * @param entryId the primary key of the current bookmarks entry 1145 * @param groupId the group ID 1146 * @param folderId the folder ID 1147 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1148 * @return the previous, current, and next bookmarks entry 1149 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1150 * @throws SystemException if a system exception occurred 1151 */ 1152 public com.liferay.portlet.bookmarks.model.BookmarksEntry[] filterFindByG_F_PrevAndNext( 1153 long entryId, long groupId, long folderId, 1154 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1155 throws com.liferay.portal.kernel.exception.SystemException, 1156 com.liferay.portlet.bookmarks.NoSuchEntryException; 1157 1158 /** 1159 * Returns all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 1160 * 1161 * @param groupId the group ID 1162 * @param folderIds the folder IDs 1163 * @return the matching bookmarks entries that the user has permission to view 1164 * @throws SystemException if a system exception occurred 1165 */ 1166 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 1167 long groupId, long[] folderIds) 1168 throws com.liferay.portal.kernel.exception.SystemException; 1169 1170 /** 1171 * Returns a range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 1172 * 1173 * <p> 1174 * 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. 1175 * </p> 1176 * 1177 * @param groupId the group ID 1178 * @param folderIds the folder IDs 1179 * @param start the lower bound of the range of bookmarks entries 1180 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1181 * @return the range of matching bookmarks entries that the user has permission to view 1182 * @throws SystemException if a system exception occurred 1183 */ 1184 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 1185 long groupId, long[] folderIds, int start, int end) 1186 throws com.liferay.portal.kernel.exception.SystemException; 1187 1188 /** 1189 * Returns an ordered range of all the bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 1190 * 1191 * <p> 1192 * 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. 1193 * </p> 1194 * 1195 * @param groupId the group ID 1196 * @param folderIds the folder IDs 1197 * @param start the lower bound of the range of bookmarks entries 1198 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1199 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1200 * @return the ordered range of matching bookmarks entries that the user has permission to view 1201 * @throws SystemException if a system exception occurred 1202 */ 1203 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> filterFindByG_F( 1204 long groupId, long[] folderIds, int start, int end, 1205 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1206 throws com.liferay.portal.kernel.exception.SystemException; 1207 1208 /** 1209 * Returns all the bookmarks entries where groupId = ? and folderId = any ?. 1210 * 1211 * <p> 1212 * 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. 1213 * </p> 1214 * 1215 * @param groupId the group ID 1216 * @param folderIds the folder IDs 1217 * @return the matching bookmarks entries 1218 * @throws SystemException if a system exception occurred 1219 */ 1220 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 1221 long groupId, long[] folderIds) 1222 throws com.liferay.portal.kernel.exception.SystemException; 1223 1224 /** 1225 * Returns a range of all the bookmarks entries where groupId = ? and folderId = any ?. 1226 * 1227 * <p> 1228 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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. 1229 * </p> 1230 * 1231 * @param groupId the group ID 1232 * @param folderIds the folder IDs 1233 * @param start the lower bound of the range of bookmarks entries 1234 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1235 * @return the range of matching bookmarks entries 1236 * @throws SystemException if a system exception occurred 1237 */ 1238 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 1239 long groupId, long[] folderIds, int start, int end) 1240 throws com.liferay.portal.kernel.exception.SystemException; 1241 1242 /** 1243 * Returns an ordered range of all the bookmarks entries where groupId = ? and folderId = any ?. 1244 * 1245 * <p> 1246 * 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. 1247 * </p> 1248 * 1249 * @param groupId the group ID 1250 * @param folderIds the folder IDs 1251 * @param start the lower bound of the range of bookmarks entries 1252 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1253 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1254 * @return the ordered range of matching bookmarks entries 1255 * @throws SystemException if a system exception occurred 1256 */ 1257 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findByG_F( 1258 long groupId, long[] folderIds, int start, int end, 1259 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1260 throws com.liferay.portal.kernel.exception.SystemException; 1261 1262 /** 1263 * Removes all the bookmarks entries where groupId = ? and folderId = ? from the database. 1264 * 1265 * @param groupId the group ID 1266 * @param folderId the folder ID 1267 * @throws SystemException if a system exception occurred 1268 */ 1269 public void removeByG_F(long groupId, long folderId) 1270 throws com.liferay.portal.kernel.exception.SystemException; 1271 1272 /** 1273 * Returns the number of bookmarks entries where groupId = ? and folderId = ?. 1274 * 1275 * @param groupId the group ID 1276 * @param folderId the folder ID 1277 * @return the number of matching bookmarks entries 1278 * @throws SystemException if a system exception occurred 1279 */ 1280 public int countByG_F(long groupId, long folderId) 1281 throws com.liferay.portal.kernel.exception.SystemException; 1282 1283 /** 1284 * Returns the number of bookmarks entries where groupId = ? and folderId = any ?. 1285 * 1286 * @param groupId the group ID 1287 * @param folderIds the folder IDs 1288 * @return the number of matching bookmarks entries 1289 * @throws SystemException if a system exception occurred 1290 */ 1291 public int countByG_F(long groupId, long[] folderIds) 1292 throws com.liferay.portal.kernel.exception.SystemException; 1293 1294 /** 1295 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = ?. 1296 * 1297 * @param groupId the group ID 1298 * @param folderId the folder ID 1299 * @return the number of matching bookmarks entries that the user has permission to view 1300 * @throws SystemException if a system exception occurred 1301 */ 1302 public int filterCountByG_F(long groupId, long folderId) 1303 throws com.liferay.portal.kernel.exception.SystemException; 1304 1305 /** 1306 * Returns the number of bookmarks entries that the user has permission to view where groupId = ? and folderId = any ?. 1307 * 1308 * @param groupId the group ID 1309 * @param folderIds the folder IDs 1310 * @return the number of matching bookmarks entries that the user has permission to view 1311 * @throws SystemException if a system exception occurred 1312 */ 1313 public int filterCountByG_F(long groupId, long[] folderIds) 1314 throws com.liferay.portal.kernel.exception.SystemException; 1315 1316 /** 1317 * Caches the bookmarks entry in the entity cache if it is enabled. 1318 * 1319 * @param bookmarksEntry the bookmarks entry 1320 */ 1321 public void cacheResult( 1322 com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry); 1323 1324 /** 1325 * Caches the bookmarks entries in the entity cache if it is enabled. 1326 * 1327 * @param bookmarksEntries the bookmarks entries 1328 */ 1329 public void cacheResult( 1330 java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> bookmarksEntries); 1331 1332 /** 1333 * Creates a new bookmarks entry with the primary key. Does not add the bookmarks entry to the database. 1334 * 1335 * @param entryId the primary key for the new bookmarks entry 1336 * @return the new bookmarks entry 1337 */ 1338 public com.liferay.portlet.bookmarks.model.BookmarksEntry create( 1339 long entryId); 1340 1341 /** 1342 * Removes the bookmarks entry with the primary key from the database. Also notifies the appropriate model listeners. 1343 * 1344 * @param entryId the primary key of the bookmarks entry 1345 * @return the bookmarks entry that was removed 1346 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1347 * @throws SystemException if a system exception occurred 1348 */ 1349 public com.liferay.portlet.bookmarks.model.BookmarksEntry remove( 1350 long entryId) 1351 throws com.liferay.portal.kernel.exception.SystemException, 1352 com.liferay.portlet.bookmarks.NoSuchEntryException; 1353 1354 public com.liferay.portlet.bookmarks.model.BookmarksEntry updateImpl( 1355 com.liferay.portlet.bookmarks.model.BookmarksEntry bookmarksEntry) 1356 throws com.liferay.portal.kernel.exception.SystemException; 1357 1358 /** 1359 * Returns the bookmarks entry with the primary key or throws a {@link com.liferay.portlet.bookmarks.NoSuchEntryException} if it could not be found. 1360 * 1361 * @param entryId the primary key of the bookmarks entry 1362 * @return the bookmarks entry 1363 * @throws com.liferay.portlet.bookmarks.NoSuchEntryException if a bookmarks entry with the primary key could not be found 1364 * @throws SystemException if a system exception occurred 1365 */ 1366 public com.liferay.portlet.bookmarks.model.BookmarksEntry findByPrimaryKey( 1367 long entryId) 1368 throws com.liferay.portal.kernel.exception.SystemException, 1369 com.liferay.portlet.bookmarks.NoSuchEntryException; 1370 1371 /** 1372 * Returns the bookmarks entry with the primary key or returns <code>null</code> if it could not be found. 1373 * 1374 * @param entryId the primary key of the bookmarks entry 1375 * @return the bookmarks entry, or <code>null</code> if a bookmarks entry with the primary key could not be found 1376 * @throws SystemException if a system exception occurred 1377 */ 1378 public com.liferay.portlet.bookmarks.model.BookmarksEntry fetchByPrimaryKey( 1379 long entryId) 1380 throws com.liferay.portal.kernel.exception.SystemException; 1381 1382 /** 1383 * Returns all the bookmarks entries. 1384 * 1385 * @return the bookmarks entries 1386 * @throws SystemException if a system exception occurred 1387 */ 1388 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll() 1389 throws com.liferay.portal.kernel.exception.SystemException; 1390 1391 /** 1392 * Returns a range of all the bookmarks entries. 1393 * 1394 * <p> 1395 * 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. 1396 * </p> 1397 * 1398 * @param start the lower bound of the range of bookmarks entries 1399 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1400 * @return the range of bookmarks entries 1401 * @throws SystemException if a system exception occurred 1402 */ 1403 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll( 1404 int start, int end) 1405 throws com.liferay.portal.kernel.exception.SystemException; 1406 1407 /** 1408 * Returns an ordered range of all the bookmarks entries. 1409 * 1410 * <p> 1411 * 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. 1412 * </p> 1413 * 1414 * @param start the lower bound of the range of bookmarks entries 1415 * @param end the upper bound of the range of bookmarks entries (not inclusive) 1416 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1417 * @return the ordered range of bookmarks entries 1418 * @throws SystemException if a system exception occurred 1419 */ 1420 public java.util.List<com.liferay.portlet.bookmarks.model.BookmarksEntry> findAll( 1421 int start, int end, 1422 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1423 throws com.liferay.portal.kernel.exception.SystemException; 1424 1425 /** 1426 * Removes all the bookmarks entries from the database. 1427 * 1428 * @throws SystemException if a system exception occurred 1429 */ 1430 public void removeAll() 1431 throws com.liferay.portal.kernel.exception.SystemException; 1432 1433 /** 1434 * Returns the number of bookmarks entries. 1435 * 1436 * @return the number of bookmarks entries 1437 * @throws SystemException if a system exception occurred 1438 */ 1439 public int countAll() 1440 throws com.liferay.portal.kernel.exception.SystemException; 1441 }