001 /** 002 * Copyright (c) 2000-present Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portal.kernel.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.kernel.exception.NoSuchPortletPreferencesException; 020 import com.liferay.portal.kernel.model.PortletPreferences; 021 022 /** 023 * The persistence interface for the portlet preferences service. 024 * 025 * <p> 026 * Caching information and settings can be found in <code>portal.properties</code> 027 * </p> 028 * 029 * @author Brian Wing Shun Chan 030 * @see com.liferay.portal.service.persistence.impl.PortletPreferencesPersistenceImpl 031 * @see PortletPreferencesUtil 032 * @generated 033 */ 034 @ProviderType 035 public interface PortletPreferencesPersistence extends BasePersistence<PortletPreferences> { 036 /* 037 * NOTE FOR DEVELOPERS: 038 * 039 * Never modify or reference this interface directly. Always use {@link PortletPreferencesUtil} to access the portlet preferences persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 040 */ 041 042 /** 043 * Returns all the portlet preferenceses where plid = ?. 044 * 045 * @param plid the plid 046 * @return the matching portlet preferenceses 047 */ 048 public java.util.List<PortletPreferences> findByPlid(long plid); 049 050 /** 051 * Returns a range of all the portlet preferenceses where plid = ?. 052 * 053 * <p> 054 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PortletPreferencesModelImpl}. 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. 055 * </p> 056 * 057 * @param plid the plid 058 * @param start the lower bound of the range of portlet preferenceses 059 * @param end the upper bound of the range of portlet preferenceses (not inclusive) 060 * @return the range of matching portlet preferenceses 061 */ 062 public java.util.List<PortletPreferences> findByPlid(long plid, int start, 063 int end); 064 065 /** 066 * Returns an ordered range of all the portlet preferenceses where plid = ?. 067 * 068 * <p> 069 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PortletPreferencesModelImpl}. 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. 070 * </p> 071 * 072 * @param plid the plid 073 * @param start the lower bound of the range of portlet preferenceses 074 * @param end the upper bound of the range of portlet preferenceses (not inclusive) 075 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 076 * @return the ordered range of matching portlet preferenceses 077 */ 078 public java.util.List<PortletPreferences> findByPlid(long plid, int start, 079 int end, 080 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator); 081 082 /** 083 * Returns an ordered range of all the portlet preferenceses where plid = ?. 084 * 085 * <p> 086 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PortletPreferencesModelImpl}. 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. 087 * </p> 088 * 089 * @param plid the plid 090 * @param start the lower bound of the range of portlet preferenceses 091 * @param end the upper bound of the range of portlet preferenceses (not inclusive) 092 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 093 * @param retrieveFromCache whether to retrieve from the finder cache 094 * @return the ordered range of matching portlet preferenceses 095 */ 096 public java.util.List<PortletPreferences> findByPlid(long plid, int start, 097 int end, 098 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator, 099 boolean retrieveFromCache); 100 101 /** 102 * Returns the first portlet preferences in the ordered set where plid = ?. 103 * 104 * @param plid the plid 105 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 106 * @return the first matching portlet preferences 107 * @throws NoSuchPortletPreferencesException if a matching portlet preferences could not be found 108 */ 109 public PortletPreferences findByPlid_First(long plid, 110 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator) 111 throws NoSuchPortletPreferencesException; 112 113 /** 114 * Returns the first portlet preferences in the ordered set where plid = ?. 115 * 116 * @param plid the plid 117 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 118 * @return the first matching portlet preferences, or <code>null</code> if a matching portlet preferences could not be found 119 */ 120 public PortletPreferences fetchByPlid_First(long plid, 121 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator); 122 123 /** 124 * Returns the last portlet preferences in the ordered set where plid = ?. 125 * 126 * @param plid the plid 127 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 128 * @return the last matching portlet preferences 129 * @throws NoSuchPortletPreferencesException if a matching portlet preferences could not be found 130 */ 131 public PortletPreferences findByPlid_Last(long plid, 132 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator) 133 throws NoSuchPortletPreferencesException; 134 135 /** 136 * Returns the last portlet preferences in the ordered set where plid = ?. 137 * 138 * @param plid the plid 139 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 140 * @return the last matching portlet preferences, or <code>null</code> if a matching portlet preferences could not be found 141 */ 142 public PortletPreferences fetchByPlid_Last(long plid, 143 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator); 144 145 /** 146 * Returns the portlet preferenceses before and after the current portlet preferences in the ordered set where plid = ?. 147 * 148 * @param portletPreferencesId the primary key of the current portlet preferences 149 * @param plid the plid 150 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 151 * @return the previous, current, and next portlet preferences 152 * @throws NoSuchPortletPreferencesException if a portlet preferences with the primary key could not be found 153 */ 154 public PortletPreferences[] findByPlid_PrevAndNext( 155 long portletPreferencesId, long plid, 156 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator) 157 throws NoSuchPortletPreferencesException; 158 159 /** 160 * Removes all the portlet preferenceses where plid = ? from the database. 161 * 162 * @param plid the plid 163 */ 164 public void removeByPlid(long plid); 165 166 /** 167 * Returns the number of portlet preferenceses where plid = ?. 168 * 169 * @param plid the plid 170 * @return the number of matching portlet preferenceses 171 */ 172 public int countByPlid(long plid); 173 174 /** 175 * Returns all the portlet preferenceses where portletId = ?. 176 * 177 * @param portletId the portlet ID 178 * @return the matching portlet preferenceses 179 */ 180 public java.util.List<PortletPreferences> findByPortletId( 181 java.lang.String portletId); 182 183 /** 184 * Returns a range of all the portlet preferenceses where portletId = ?. 185 * 186 * <p> 187 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PortletPreferencesModelImpl}. 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. 188 * </p> 189 * 190 * @param portletId the portlet ID 191 * @param start the lower bound of the range of portlet preferenceses 192 * @param end the upper bound of the range of portlet preferenceses (not inclusive) 193 * @return the range of matching portlet preferenceses 194 */ 195 public java.util.List<PortletPreferences> findByPortletId( 196 java.lang.String portletId, int start, int end); 197 198 /** 199 * Returns an ordered range of all the portlet preferenceses where portletId = ?. 200 * 201 * <p> 202 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PortletPreferencesModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 203 * </p> 204 * 205 * @param portletId the portlet ID 206 * @param start the lower bound of the range of portlet preferenceses 207 * @param end the upper bound of the range of portlet preferenceses (not inclusive) 208 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 209 * @return the ordered range of matching portlet preferenceses 210 */ 211 public java.util.List<PortletPreferences> findByPortletId( 212 java.lang.String portletId, int start, int end, 213 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator); 214 215 /** 216 * Returns an ordered range of all the portlet preferenceses where portletId = ?. 217 * 218 * <p> 219 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PortletPreferencesModelImpl}. 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. 220 * </p> 221 * 222 * @param portletId the portlet ID 223 * @param start the lower bound of the range of portlet preferenceses 224 * @param end the upper bound of the range of portlet preferenceses (not inclusive) 225 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 226 * @param retrieveFromCache whether to retrieve from the finder cache 227 * @return the ordered range of matching portlet preferenceses 228 */ 229 public java.util.List<PortletPreferences> findByPortletId( 230 java.lang.String portletId, int start, int end, 231 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator, 232 boolean retrieveFromCache); 233 234 /** 235 * Returns the first portlet preferences in the ordered set where portletId = ?. 236 * 237 * @param portletId the portlet ID 238 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 239 * @return the first matching portlet preferences 240 * @throws NoSuchPortletPreferencesException if a matching portlet preferences could not be found 241 */ 242 public PortletPreferences findByPortletId_First( 243 java.lang.String portletId, 244 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator) 245 throws NoSuchPortletPreferencesException; 246 247 /** 248 * Returns the first portlet preferences in the ordered set where portletId = ?. 249 * 250 * @param portletId the portlet ID 251 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 252 * @return the first matching portlet preferences, or <code>null</code> if a matching portlet preferences could not be found 253 */ 254 public PortletPreferences fetchByPortletId_First( 255 java.lang.String portletId, 256 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator); 257 258 /** 259 * Returns the last portlet preferences in the ordered set where portletId = ?. 260 * 261 * @param portletId the portlet ID 262 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 263 * @return the last matching portlet preferences 264 * @throws NoSuchPortletPreferencesException if a matching portlet preferences could not be found 265 */ 266 public PortletPreferences findByPortletId_Last(java.lang.String portletId, 267 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator) 268 throws NoSuchPortletPreferencesException; 269 270 /** 271 * Returns the last portlet preferences in the ordered set where portletId = ?. 272 * 273 * @param portletId the portlet ID 274 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 275 * @return the last matching portlet preferences, or <code>null</code> if a matching portlet preferences could not be found 276 */ 277 public PortletPreferences fetchByPortletId_Last( 278 java.lang.String portletId, 279 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator); 280 281 /** 282 * Returns the portlet preferenceses before and after the current portlet preferences in the ordered set where portletId = ?. 283 * 284 * @param portletPreferencesId the primary key of the current portlet preferences 285 * @param portletId the portlet ID 286 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 287 * @return the previous, current, and next portlet preferences 288 * @throws NoSuchPortletPreferencesException if a portlet preferences with the primary key could not be found 289 */ 290 public PortletPreferences[] findByPortletId_PrevAndNext( 291 long portletPreferencesId, java.lang.String portletId, 292 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator) 293 throws NoSuchPortletPreferencesException; 294 295 /** 296 * Removes all the portlet preferenceses where portletId = ? from the database. 297 * 298 * @param portletId the portlet ID 299 */ 300 public void removeByPortletId(java.lang.String portletId); 301 302 /** 303 * Returns the number of portlet preferenceses where portletId = ?. 304 * 305 * @param portletId the portlet ID 306 * @return the number of matching portlet preferenceses 307 */ 308 public int countByPortletId(java.lang.String portletId); 309 310 /** 311 * Returns all the portlet preferenceses where ownerType = ? and portletId = ?. 312 * 313 * @param ownerType the owner type 314 * @param portletId the portlet ID 315 * @return the matching portlet preferenceses 316 */ 317 public java.util.List<PortletPreferences> findByO_P(int ownerType, 318 java.lang.String portletId); 319 320 /** 321 * Returns a range of all the portlet preferenceses where ownerType = ? and portletId = ?. 322 * 323 * <p> 324 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PortletPreferencesModelImpl}. 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. 325 * </p> 326 * 327 * @param ownerType the owner type 328 * @param portletId the portlet ID 329 * @param start the lower bound of the range of portlet preferenceses 330 * @param end the upper bound of the range of portlet preferenceses (not inclusive) 331 * @return the range of matching portlet preferenceses 332 */ 333 public java.util.List<PortletPreferences> findByO_P(int ownerType, 334 java.lang.String portletId, int start, int end); 335 336 /** 337 * Returns an ordered range of all the portlet preferenceses where ownerType = ? and portletId = ?. 338 * 339 * <p> 340 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PortletPreferencesModelImpl}. 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. 341 * </p> 342 * 343 * @param ownerType the owner type 344 * @param portletId the portlet ID 345 * @param start the lower bound of the range of portlet preferenceses 346 * @param end the upper bound of the range of portlet preferenceses (not inclusive) 347 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 348 * @return the ordered range of matching portlet preferenceses 349 */ 350 public java.util.List<PortletPreferences> findByO_P(int ownerType, 351 java.lang.String portletId, int start, int end, 352 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator); 353 354 /** 355 * Returns an ordered range of all the portlet preferenceses where ownerType = ? and portletId = ?. 356 * 357 * <p> 358 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PortletPreferencesModelImpl}. 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. 359 * </p> 360 * 361 * @param ownerType the owner type 362 * @param portletId the portlet ID 363 * @param start the lower bound of the range of portlet preferenceses 364 * @param end the upper bound of the range of portlet preferenceses (not inclusive) 365 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 366 * @param retrieveFromCache whether to retrieve from the finder cache 367 * @return the ordered range of matching portlet preferenceses 368 */ 369 public java.util.List<PortletPreferences> findByO_P(int ownerType, 370 java.lang.String portletId, int start, int end, 371 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator, 372 boolean retrieveFromCache); 373 374 /** 375 * Returns the first portlet preferences in the ordered set where ownerType = ? and portletId = ?. 376 * 377 * @param ownerType the owner type 378 * @param portletId the portlet ID 379 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 380 * @return the first matching portlet preferences 381 * @throws NoSuchPortletPreferencesException if a matching portlet preferences could not be found 382 */ 383 public PortletPreferences findByO_P_First(int ownerType, 384 java.lang.String portletId, 385 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator) 386 throws NoSuchPortletPreferencesException; 387 388 /** 389 * Returns the first portlet preferences in the ordered set where ownerType = ? and portletId = ?. 390 * 391 * @param ownerType the owner type 392 * @param portletId the portlet ID 393 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 394 * @return the first matching portlet preferences, or <code>null</code> if a matching portlet preferences could not be found 395 */ 396 public PortletPreferences fetchByO_P_First(int ownerType, 397 java.lang.String portletId, 398 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator); 399 400 /** 401 * Returns the last portlet preferences in the ordered set where ownerType = ? and portletId = ?. 402 * 403 * @param ownerType the owner type 404 * @param portletId the portlet ID 405 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 406 * @return the last matching portlet preferences 407 * @throws NoSuchPortletPreferencesException if a matching portlet preferences could not be found 408 */ 409 public PortletPreferences findByO_P_Last(int ownerType, 410 java.lang.String portletId, 411 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator) 412 throws NoSuchPortletPreferencesException; 413 414 /** 415 * Returns the last portlet preferences in the ordered set where ownerType = ? and portletId = ?. 416 * 417 * @param ownerType the owner type 418 * @param portletId the portlet ID 419 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 420 * @return the last matching portlet preferences, or <code>null</code> if a matching portlet preferences could not be found 421 */ 422 public PortletPreferences fetchByO_P_Last(int ownerType, 423 java.lang.String portletId, 424 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator); 425 426 /** 427 * Returns the portlet preferenceses before and after the current portlet preferences in the ordered set where ownerType = ? and portletId = ?. 428 * 429 * @param portletPreferencesId the primary key of the current portlet preferences 430 * @param ownerType the owner type 431 * @param portletId the portlet ID 432 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 433 * @return the previous, current, and next portlet preferences 434 * @throws NoSuchPortletPreferencesException if a portlet preferences with the primary key could not be found 435 */ 436 public PortletPreferences[] findByO_P_PrevAndNext( 437 long portletPreferencesId, int ownerType, java.lang.String portletId, 438 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator) 439 throws NoSuchPortletPreferencesException; 440 441 /** 442 * Removes all the portlet preferenceses where ownerType = ? and portletId = ? from the database. 443 * 444 * @param ownerType the owner type 445 * @param portletId the portlet ID 446 */ 447 public void removeByO_P(int ownerType, java.lang.String portletId); 448 449 /** 450 * Returns the number of portlet preferenceses where ownerType = ? and portletId = ?. 451 * 452 * @param ownerType the owner type 453 * @param portletId the portlet ID 454 * @return the number of matching portlet preferenceses 455 */ 456 public int countByO_P(int ownerType, java.lang.String portletId); 457 458 /** 459 * Returns all the portlet preferenceses where plid = ? and portletId = ?. 460 * 461 * @param plid the plid 462 * @param portletId the portlet ID 463 * @return the matching portlet preferenceses 464 */ 465 public java.util.List<PortletPreferences> findByP_P(long plid, 466 java.lang.String portletId); 467 468 /** 469 * Returns a range of all the portlet preferenceses where plid = ? and portletId = ?. 470 * 471 * <p> 472 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PortletPreferencesModelImpl}. 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. 473 * </p> 474 * 475 * @param plid the plid 476 * @param portletId the portlet ID 477 * @param start the lower bound of the range of portlet preferenceses 478 * @param end the upper bound of the range of portlet preferenceses (not inclusive) 479 * @return the range of matching portlet preferenceses 480 */ 481 public java.util.List<PortletPreferences> findByP_P(long plid, 482 java.lang.String portletId, int start, int end); 483 484 /** 485 * Returns an ordered range of all the portlet preferenceses where plid = ? and portletId = ?. 486 * 487 * <p> 488 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PortletPreferencesModelImpl}. 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. 489 * </p> 490 * 491 * @param plid the plid 492 * @param portletId the portlet ID 493 * @param start the lower bound of the range of portlet preferenceses 494 * @param end the upper bound of the range of portlet preferenceses (not inclusive) 495 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 496 * @return the ordered range of matching portlet preferenceses 497 */ 498 public java.util.List<PortletPreferences> findByP_P(long plid, 499 java.lang.String portletId, int start, int end, 500 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator); 501 502 /** 503 * Returns an ordered range of all the portlet preferenceses where plid = ? and portletId = ?. 504 * 505 * <p> 506 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PortletPreferencesModelImpl}. 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. 507 * </p> 508 * 509 * @param plid the plid 510 * @param portletId the portlet ID 511 * @param start the lower bound of the range of portlet preferenceses 512 * @param end the upper bound of the range of portlet preferenceses (not inclusive) 513 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 514 * @param retrieveFromCache whether to retrieve from the finder cache 515 * @return the ordered range of matching portlet preferenceses 516 */ 517 public java.util.List<PortletPreferences> findByP_P(long plid, 518 java.lang.String portletId, int start, int end, 519 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator, 520 boolean retrieveFromCache); 521 522 /** 523 * Returns the first portlet preferences in the ordered set where plid = ? and portletId = ?. 524 * 525 * @param plid the plid 526 * @param portletId the portlet ID 527 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 528 * @return the first matching portlet preferences 529 * @throws NoSuchPortletPreferencesException if a matching portlet preferences could not be found 530 */ 531 public PortletPreferences findByP_P_First(long plid, 532 java.lang.String portletId, 533 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator) 534 throws NoSuchPortletPreferencesException; 535 536 /** 537 * Returns the first portlet preferences in the ordered set where plid = ? and portletId = ?. 538 * 539 * @param plid the plid 540 * @param portletId the portlet ID 541 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 542 * @return the first matching portlet preferences, or <code>null</code> if a matching portlet preferences could not be found 543 */ 544 public PortletPreferences fetchByP_P_First(long plid, 545 java.lang.String portletId, 546 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator); 547 548 /** 549 * Returns the last portlet preferences in the ordered set where plid = ? and portletId = ?. 550 * 551 * @param plid the plid 552 * @param portletId the portlet ID 553 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 554 * @return the last matching portlet preferences 555 * @throws NoSuchPortletPreferencesException if a matching portlet preferences could not be found 556 */ 557 public PortletPreferences findByP_P_Last(long plid, 558 java.lang.String portletId, 559 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator) 560 throws NoSuchPortletPreferencesException; 561 562 /** 563 * Returns the last portlet preferences in the ordered set where plid = ? and portletId = ?. 564 * 565 * @param plid the plid 566 * @param portletId the portlet ID 567 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 568 * @return the last matching portlet preferences, or <code>null</code> if a matching portlet preferences could not be found 569 */ 570 public PortletPreferences fetchByP_P_Last(long plid, 571 java.lang.String portletId, 572 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator); 573 574 /** 575 * Returns the portlet preferenceses before and after the current portlet preferences in the ordered set where plid = ? and portletId = ?. 576 * 577 * @param portletPreferencesId the primary key of the current portlet preferences 578 * @param plid the plid 579 * @param portletId the portlet ID 580 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 581 * @return the previous, current, and next portlet preferences 582 * @throws NoSuchPortletPreferencesException if a portlet preferences with the primary key could not be found 583 */ 584 public PortletPreferences[] findByP_P_PrevAndNext( 585 long portletPreferencesId, long plid, java.lang.String portletId, 586 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator) 587 throws NoSuchPortletPreferencesException; 588 589 /** 590 * Removes all the portlet preferenceses where plid = ? and portletId = ? from the database. 591 * 592 * @param plid the plid 593 * @param portletId the portlet ID 594 */ 595 public void removeByP_P(long plid, java.lang.String portletId); 596 597 /** 598 * Returns the number of portlet preferenceses where plid = ? and portletId = ?. 599 * 600 * @param plid the plid 601 * @param portletId the portlet ID 602 * @return the number of matching portlet preferenceses 603 */ 604 public int countByP_P(long plid, java.lang.String portletId); 605 606 /** 607 * Returns all the portlet preferenceses where ownerId = ? and ownerType = ? and plid = ?. 608 * 609 * @param ownerId the owner ID 610 * @param ownerType the owner type 611 * @param plid the plid 612 * @return the matching portlet preferenceses 613 */ 614 public java.util.List<PortletPreferences> findByO_O_P(long ownerId, 615 int ownerType, long plid); 616 617 /** 618 * Returns a range of all the portlet preferenceses where ownerId = ? and ownerType = ? and plid = ?. 619 * 620 * <p> 621 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PortletPreferencesModelImpl}. 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. 622 * </p> 623 * 624 * @param ownerId the owner ID 625 * @param ownerType the owner type 626 * @param plid the plid 627 * @param start the lower bound of the range of portlet preferenceses 628 * @param end the upper bound of the range of portlet preferenceses (not inclusive) 629 * @return the range of matching portlet preferenceses 630 */ 631 public java.util.List<PortletPreferences> findByO_O_P(long ownerId, 632 int ownerType, long plid, int start, int end); 633 634 /** 635 * Returns an ordered range of all the portlet preferenceses where ownerId = ? and ownerType = ? and plid = ?. 636 * 637 * <p> 638 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PortletPreferencesModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 639 * </p> 640 * 641 * @param ownerId the owner ID 642 * @param ownerType the owner type 643 * @param plid the plid 644 * @param start the lower bound of the range of portlet preferenceses 645 * @param end the upper bound of the range of portlet preferenceses (not inclusive) 646 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 647 * @return the ordered range of matching portlet preferenceses 648 */ 649 public java.util.List<PortletPreferences> findByO_O_P(long ownerId, 650 int ownerType, long plid, int start, int end, 651 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator); 652 653 /** 654 * Returns an ordered range of all the portlet preferenceses where ownerId = ? and ownerType = ? and plid = ?. 655 * 656 * <p> 657 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PortletPreferencesModelImpl}. 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. 658 * </p> 659 * 660 * @param ownerId the owner ID 661 * @param ownerType the owner type 662 * @param plid the plid 663 * @param start the lower bound of the range of portlet preferenceses 664 * @param end the upper bound of the range of portlet preferenceses (not inclusive) 665 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 666 * @param retrieveFromCache whether to retrieve from the finder cache 667 * @return the ordered range of matching portlet preferenceses 668 */ 669 public java.util.List<PortletPreferences> findByO_O_P(long ownerId, 670 int ownerType, long plid, int start, int end, 671 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator, 672 boolean retrieveFromCache); 673 674 /** 675 * Returns the first portlet preferences in the ordered set where ownerId = ? and ownerType = ? and plid = ?. 676 * 677 * @param ownerId the owner ID 678 * @param ownerType the owner type 679 * @param plid the plid 680 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 681 * @return the first matching portlet preferences 682 * @throws NoSuchPortletPreferencesException if a matching portlet preferences could not be found 683 */ 684 public PortletPreferences findByO_O_P_First(long ownerId, int ownerType, 685 long plid, 686 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator) 687 throws NoSuchPortletPreferencesException; 688 689 /** 690 * Returns the first portlet preferences in the ordered set where ownerId = ? and ownerType = ? and plid = ?. 691 * 692 * @param ownerId the owner ID 693 * @param ownerType the owner type 694 * @param plid the plid 695 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 696 * @return the first matching portlet preferences, or <code>null</code> if a matching portlet preferences could not be found 697 */ 698 public PortletPreferences fetchByO_O_P_First(long ownerId, int ownerType, 699 long plid, 700 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator); 701 702 /** 703 * Returns the last portlet preferences in the ordered set where ownerId = ? and ownerType = ? and plid = ?. 704 * 705 * @param ownerId the owner ID 706 * @param ownerType the owner type 707 * @param plid the plid 708 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 709 * @return the last matching portlet preferences 710 * @throws NoSuchPortletPreferencesException if a matching portlet preferences could not be found 711 */ 712 public PortletPreferences findByO_O_P_Last(long ownerId, int ownerType, 713 long plid, 714 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator) 715 throws NoSuchPortletPreferencesException; 716 717 /** 718 * Returns the last portlet preferences in the ordered set where ownerId = ? and ownerType = ? and plid = ?. 719 * 720 * @param ownerId the owner ID 721 * @param ownerType the owner type 722 * @param plid the plid 723 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 724 * @return the last matching portlet preferences, or <code>null</code> if a matching portlet preferences could not be found 725 */ 726 public PortletPreferences fetchByO_O_P_Last(long ownerId, int ownerType, 727 long plid, 728 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator); 729 730 /** 731 * Returns the portlet preferenceses before and after the current portlet preferences in the ordered set where ownerId = ? and ownerType = ? and plid = ?. 732 * 733 * @param portletPreferencesId the primary key of the current portlet preferences 734 * @param ownerId the owner ID 735 * @param ownerType the owner type 736 * @param plid the plid 737 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 738 * @return the previous, current, and next portlet preferences 739 * @throws NoSuchPortletPreferencesException if a portlet preferences with the primary key could not be found 740 */ 741 public PortletPreferences[] findByO_O_P_PrevAndNext( 742 long portletPreferencesId, long ownerId, int ownerType, long plid, 743 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator) 744 throws NoSuchPortletPreferencesException; 745 746 /** 747 * Removes all the portlet preferenceses where ownerId = ? and ownerType = ? and plid = ? from the database. 748 * 749 * @param ownerId the owner ID 750 * @param ownerType the owner type 751 * @param plid the plid 752 */ 753 public void removeByO_O_P(long ownerId, int ownerType, long plid); 754 755 /** 756 * Returns the number of portlet preferenceses where ownerId = ? and ownerType = ? and plid = ?. 757 * 758 * @param ownerId the owner ID 759 * @param ownerType the owner type 760 * @param plid the plid 761 * @return the number of matching portlet preferenceses 762 */ 763 public int countByO_O_P(long ownerId, int ownerType, long plid); 764 765 /** 766 * Returns all the portlet preferenceses where ownerId = ? and ownerType = ? and portletId = ?. 767 * 768 * @param ownerId the owner ID 769 * @param ownerType the owner type 770 * @param portletId the portlet ID 771 * @return the matching portlet preferenceses 772 */ 773 public java.util.List<PortletPreferences> findByO_O_PI(long ownerId, 774 int ownerType, java.lang.String portletId); 775 776 /** 777 * Returns a range of all the portlet preferenceses where ownerId = ? and ownerType = ? and portletId = ?. 778 * 779 * <p> 780 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PortletPreferencesModelImpl}. 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. 781 * </p> 782 * 783 * @param ownerId the owner ID 784 * @param ownerType the owner type 785 * @param portletId the portlet ID 786 * @param start the lower bound of the range of portlet preferenceses 787 * @param end the upper bound of the range of portlet preferenceses (not inclusive) 788 * @return the range of matching portlet preferenceses 789 */ 790 public java.util.List<PortletPreferences> findByO_O_PI(long ownerId, 791 int ownerType, java.lang.String portletId, int start, int end); 792 793 /** 794 * Returns an ordered range of all the portlet preferenceses where ownerId = ? and ownerType = ? and portletId = ?. 795 * 796 * <p> 797 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PortletPreferencesModelImpl}. 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. 798 * </p> 799 * 800 * @param ownerId the owner ID 801 * @param ownerType the owner type 802 * @param portletId the portlet ID 803 * @param start the lower bound of the range of portlet preferenceses 804 * @param end the upper bound of the range of portlet preferenceses (not inclusive) 805 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 806 * @return the ordered range of matching portlet preferenceses 807 */ 808 public java.util.List<PortletPreferences> findByO_O_PI(long ownerId, 809 int ownerType, java.lang.String portletId, int start, int end, 810 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator); 811 812 /** 813 * Returns an ordered range of all the portlet preferenceses where ownerId = ? and ownerType = ? and portletId = ?. 814 * 815 * <p> 816 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PortletPreferencesModelImpl}. 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. 817 * </p> 818 * 819 * @param ownerId the owner ID 820 * @param ownerType the owner type 821 * @param portletId the portlet ID 822 * @param start the lower bound of the range of portlet preferenceses 823 * @param end the upper bound of the range of portlet preferenceses (not inclusive) 824 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 825 * @param retrieveFromCache whether to retrieve from the finder cache 826 * @return the ordered range of matching portlet preferenceses 827 */ 828 public java.util.List<PortletPreferences> findByO_O_PI(long ownerId, 829 int ownerType, java.lang.String portletId, int start, int end, 830 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator, 831 boolean retrieveFromCache); 832 833 /** 834 * Returns the first portlet preferences in the ordered set where ownerId = ? and ownerType = ? and portletId = ?. 835 * 836 * @param ownerId the owner ID 837 * @param ownerType the owner type 838 * @param portletId the portlet ID 839 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 840 * @return the first matching portlet preferences 841 * @throws NoSuchPortletPreferencesException if a matching portlet preferences could not be found 842 */ 843 public PortletPreferences findByO_O_PI_First(long ownerId, int ownerType, 844 java.lang.String portletId, 845 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator) 846 throws NoSuchPortletPreferencesException; 847 848 /** 849 * Returns the first portlet preferences in the ordered set where ownerId = ? and ownerType = ? and portletId = ?. 850 * 851 * @param ownerId the owner ID 852 * @param ownerType the owner type 853 * @param portletId the portlet ID 854 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 855 * @return the first matching portlet preferences, or <code>null</code> if a matching portlet preferences could not be found 856 */ 857 public PortletPreferences fetchByO_O_PI_First(long ownerId, int ownerType, 858 java.lang.String portletId, 859 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator); 860 861 /** 862 * Returns the last portlet preferences in the ordered set where ownerId = ? and ownerType = ? and portletId = ?. 863 * 864 * @param ownerId the owner ID 865 * @param ownerType the owner type 866 * @param portletId the portlet ID 867 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 868 * @return the last matching portlet preferences 869 * @throws NoSuchPortletPreferencesException if a matching portlet preferences could not be found 870 */ 871 public PortletPreferences findByO_O_PI_Last(long ownerId, int ownerType, 872 java.lang.String portletId, 873 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator) 874 throws NoSuchPortletPreferencesException; 875 876 /** 877 * Returns the last portlet preferences in the ordered set where ownerId = ? and ownerType = ? and portletId = ?. 878 * 879 * @param ownerId the owner ID 880 * @param ownerType the owner type 881 * @param portletId the portlet ID 882 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 883 * @return the last matching portlet preferences, or <code>null</code> if a matching portlet preferences could not be found 884 */ 885 public PortletPreferences fetchByO_O_PI_Last(long ownerId, int ownerType, 886 java.lang.String portletId, 887 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator); 888 889 /** 890 * Returns the portlet preferenceses before and after the current portlet preferences in the ordered set where ownerId = ? and ownerType = ? and portletId = ?. 891 * 892 * @param portletPreferencesId the primary key of the current portlet preferences 893 * @param ownerId the owner ID 894 * @param ownerType the owner type 895 * @param portletId the portlet ID 896 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 897 * @return the previous, current, and next portlet preferences 898 * @throws NoSuchPortletPreferencesException if a portlet preferences with the primary key could not be found 899 */ 900 public PortletPreferences[] findByO_O_PI_PrevAndNext( 901 long portletPreferencesId, long ownerId, int ownerType, 902 java.lang.String portletId, 903 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator) 904 throws NoSuchPortletPreferencesException; 905 906 /** 907 * Removes all the portlet preferenceses where ownerId = ? and ownerType = ? and portletId = ? from the database. 908 * 909 * @param ownerId the owner ID 910 * @param ownerType the owner type 911 * @param portletId the portlet ID 912 */ 913 public void removeByO_O_PI(long ownerId, int ownerType, 914 java.lang.String portletId); 915 916 /** 917 * Returns the number of portlet preferenceses where ownerId = ? and ownerType = ? and portletId = ?. 918 * 919 * @param ownerId the owner ID 920 * @param ownerType the owner type 921 * @param portletId the portlet ID 922 * @return the number of matching portlet preferenceses 923 */ 924 public int countByO_O_PI(long ownerId, int ownerType, 925 java.lang.String portletId); 926 927 /** 928 * Returns all the portlet preferenceses where ownerType = ? and plid = ? and portletId = ?. 929 * 930 * @param ownerType the owner type 931 * @param plid the plid 932 * @param portletId the portlet ID 933 * @return the matching portlet preferenceses 934 */ 935 public java.util.List<PortletPreferences> findByO_P_P(int ownerType, 936 long plid, java.lang.String portletId); 937 938 /** 939 * Returns a range of all the portlet preferenceses where ownerType = ? and plid = ? and portletId = ?. 940 * 941 * <p> 942 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PortletPreferencesModelImpl}. 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. 943 * </p> 944 * 945 * @param ownerType the owner type 946 * @param plid the plid 947 * @param portletId the portlet ID 948 * @param start the lower bound of the range of portlet preferenceses 949 * @param end the upper bound of the range of portlet preferenceses (not inclusive) 950 * @return the range of matching portlet preferenceses 951 */ 952 public java.util.List<PortletPreferences> findByO_P_P(int ownerType, 953 long plid, java.lang.String portletId, int start, int end); 954 955 /** 956 * Returns an ordered range of all the portlet preferenceses where ownerType = ? and plid = ? and portletId = ?. 957 * 958 * <p> 959 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PortletPreferencesModelImpl}. 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. 960 * </p> 961 * 962 * @param ownerType the owner type 963 * @param plid the plid 964 * @param portletId the portlet ID 965 * @param start the lower bound of the range of portlet preferenceses 966 * @param end the upper bound of the range of portlet preferenceses (not inclusive) 967 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 968 * @return the ordered range of matching portlet preferenceses 969 */ 970 public java.util.List<PortletPreferences> findByO_P_P(int ownerType, 971 long plid, java.lang.String portletId, int start, int end, 972 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator); 973 974 /** 975 * Returns an ordered range of all the portlet preferenceses where ownerType = ? and plid = ? and portletId = ?. 976 * 977 * <p> 978 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PortletPreferencesModelImpl}. 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. 979 * </p> 980 * 981 * @param ownerType the owner type 982 * @param plid the plid 983 * @param portletId the portlet ID 984 * @param start the lower bound of the range of portlet preferenceses 985 * @param end the upper bound of the range of portlet preferenceses (not inclusive) 986 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 987 * @param retrieveFromCache whether to retrieve from the finder cache 988 * @return the ordered range of matching portlet preferenceses 989 */ 990 public java.util.List<PortletPreferences> findByO_P_P(int ownerType, 991 long plid, java.lang.String portletId, int start, int end, 992 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator, 993 boolean retrieveFromCache); 994 995 /** 996 * Returns the first portlet preferences in the ordered set where ownerType = ? and plid = ? and portletId = ?. 997 * 998 * @param ownerType the owner type 999 * @param plid the plid 1000 * @param portletId the portlet ID 1001 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1002 * @return the first matching portlet preferences 1003 * @throws NoSuchPortletPreferencesException if a matching portlet preferences could not be found 1004 */ 1005 public PortletPreferences findByO_P_P_First(int ownerType, long plid, 1006 java.lang.String portletId, 1007 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator) 1008 throws NoSuchPortletPreferencesException; 1009 1010 /** 1011 * Returns the first portlet preferences in the ordered set where ownerType = ? and plid = ? and portletId = ?. 1012 * 1013 * @param ownerType the owner type 1014 * @param plid the plid 1015 * @param portletId the portlet ID 1016 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1017 * @return the first matching portlet preferences, or <code>null</code> if a matching portlet preferences could not be found 1018 */ 1019 public PortletPreferences fetchByO_P_P_First(int ownerType, long plid, 1020 java.lang.String portletId, 1021 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator); 1022 1023 /** 1024 * Returns the last portlet preferences in the ordered set where ownerType = ? and plid = ? and portletId = ?. 1025 * 1026 * @param ownerType the owner type 1027 * @param plid the plid 1028 * @param portletId the portlet ID 1029 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1030 * @return the last matching portlet preferences 1031 * @throws NoSuchPortletPreferencesException if a matching portlet preferences could not be found 1032 */ 1033 public PortletPreferences findByO_P_P_Last(int ownerType, long plid, 1034 java.lang.String portletId, 1035 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator) 1036 throws NoSuchPortletPreferencesException; 1037 1038 /** 1039 * Returns the last portlet preferences in the ordered set where ownerType = ? and plid = ? and portletId = ?. 1040 * 1041 * @param ownerType the owner type 1042 * @param plid the plid 1043 * @param portletId the portlet ID 1044 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1045 * @return the last matching portlet preferences, or <code>null</code> if a matching portlet preferences could not be found 1046 */ 1047 public PortletPreferences fetchByO_P_P_Last(int ownerType, long plid, 1048 java.lang.String portletId, 1049 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator); 1050 1051 /** 1052 * Returns the portlet preferenceses before and after the current portlet preferences in the ordered set where ownerType = ? and plid = ? and portletId = ?. 1053 * 1054 * @param portletPreferencesId the primary key of the current portlet preferences 1055 * @param ownerType the owner type 1056 * @param plid the plid 1057 * @param portletId the portlet ID 1058 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1059 * @return the previous, current, and next portlet preferences 1060 * @throws NoSuchPortletPreferencesException if a portlet preferences with the primary key could not be found 1061 */ 1062 public PortletPreferences[] findByO_P_P_PrevAndNext( 1063 long portletPreferencesId, int ownerType, long plid, 1064 java.lang.String portletId, 1065 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator) 1066 throws NoSuchPortletPreferencesException; 1067 1068 /** 1069 * Removes all the portlet preferenceses where ownerType = ? and plid = ? and portletId = ? from the database. 1070 * 1071 * @param ownerType the owner type 1072 * @param plid the plid 1073 * @param portletId the portlet ID 1074 */ 1075 public void removeByO_P_P(int ownerType, long plid, 1076 java.lang.String portletId); 1077 1078 /** 1079 * Returns the number of portlet preferenceses where ownerType = ? and plid = ? and portletId = ?. 1080 * 1081 * @param ownerType the owner type 1082 * @param plid the plid 1083 * @param portletId the portlet ID 1084 * @return the number of matching portlet preferenceses 1085 */ 1086 public int countByO_P_P(int ownerType, long plid, java.lang.String portletId); 1087 1088 /** 1089 * Returns the portlet preferences where ownerId = ? and ownerType = ? and plid = ? and portletId = ? or throws a {@link NoSuchPortletPreferencesException} if it could not be found. 1090 * 1091 * @param ownerId the owner ID 1092 * @param ownerType the owner type 1093 * @param plid the plid 1094 * @param portletId the portlet ID 1095 * @return the matching portlet preferences 1096 * @throws NoSuchPortletPreferencesException if a matching portlet preferences could not be found 1097 */ 1098 public PortletPreferences findByO_O_P_P(long ownerId, int ownerType, 1099 long plid, java.lang.String portletId) 1100 throws NoSuchPortletPreferencesException; 1101 1102 /** 1103 * Returns the portlet preferences where ownerId = ? and ownerType = ? and plid = ? and portletId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1104 * 1105 * @param ownerId the owner ID 1106 * @param ownerType the owner type 1107 * @param plid the plid 1108 * @param portletId the portlet ID 1109 * @return the matching portlet preferences, or <code>null</code> if a matching portlet preferences could not be found 1110 */ 1111 public PortletPreferences fetchByO_O_P_P(long ownerId, int ownerType, 1112 long plid, java.lang.String portletId); 1113 1114 /** 1115 * Returns the portlet preferences where ownerId = ? and ownerType = ? and plid = ? and portletId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 1116 * 1117 * @param ownerId the owner ID 1118 * @param ownerType the owner type 1119 * @param plid the plid 1120 * @param portletId the portlet ID 1121 * @param retrieveFromCache whether to retrieve from the finder cache 1122 * @return the matching portlet preferences, or <code>null</code> if a matching portlet preferences could not be found 1123 */ 1124 public PortletPreferences fetchByO_O_P_P(long ownerId, int ownerType, 1125 long plid, java.lang.String portletId, boolean retrieveFromCache); 1126 1127 /** 1128 * Removes the portlet preferences where ownerId = ? and ownerType = ? and plid = ? and portletId = ? from the database. 1129 * 1130 * @param ownerId the owner ID 1131 * @param ownerType the owner type 1132 * @param plid the plid 1133 * @param portletId the portlet ID 1134 * @return the portlet preferences that was removed 1135 */ 1136 public PortletPreferences removeByO_O_P_P(long ownerId, int ownerType, 1137 long plid, java.lang.String portletId) 1138 throws NoSuchPortletPreferencesException; 1139 1140 /** 1141 * Returns the number of portlet preferenceses where ownerId = ? and ownerType = ? and plid = ? and portletId = ?. 1142 * 1143 * @param ownerId the owner ID 1144 * @param ownerType the owner type 1145 * @param plid the plid 1146 * @param portletId the portlet ID 1147 * @return the number of matching portlet preferenceses 1148 */ 1149 public int countByO_O_P_P(long ownerId, int ownerType, long plid, 1150 java.lang.String portletId); 1151 1152 /** 1153 * Caches the portlet preferences in the entity cache if it is enabled. 1154 * 1155 * @param portletPreferences the portlet preferences 1156 */ 1157 public void cacheResult(PortletPreferences portletPreferences); 1158 1159 /** 1160 * Caches the portlet preferenceses in the entity cache if it is enabled. 1161 * 1162 * @param portletPreferenceses the portlet preferenceses 1163 */ 1164 public void cacheResult( 1165 java.util.List<PortletPreferences> portletPreferenceses); 1166 1167 /** 1168 * Creates a new portlet preferences with the primary key. Does not add the portlet preferences to the database. 1169 * 1170 * @param portletPreferencesId the primary key for the new portlet preferences 1171 * @return the new portlet preferences 1172 */ 1173 public PortletPreferences create(long portletPreferencesId); 1174 1175 /** 1176 * Removes the portlet preferences with the primary key from the database. Also notifies the appropriate model listeners. 1177 * 1178 * @param portletPreferencesId the primary key of the portlet preferences 1179 * @return the portlet preferences that was removed 1180 * @throws NoSuchPortletPreferencesException if a portlet preferences with the primary key could not be found 1181 */ 1182 public PortletPreferences remove(long portletPreferencesId) 1183 throws NoSuchPortletPreferencesException; 1184 1185 public PortletPreferences updateImpl(PortletPreferences portletPreferences); 1186 1187 /** 1188 * Returns the portlet preferences with the primary key or throws a {@link NoSuchPortletPreferencesException} if it could not be found. 1189 * 1190 * @param portletPreferencesId the primary key of the portlet preferences 1191 * @return the portlet preferences 1192 * @throws NoSuchPortletPreferencesException if a portlet preferences with the primary key could not be found 1193 */ 1194 public PortletPreferences findByPrimaryKey(long portletPreferencesId) 1195 throws NoSuchPortletPreferencesException; 1196 1197 /** 1198 * Returns the portlet preferences with the primary key or returns <code>null</code> if it could not be found. 1199 * 1200 * @param portletPreferencesId the primary key of the portlet preferences 1201 * @return the portlet preferences, or <code>null</code> if a portlet preferences with the primary key could not be found 1202 */ 1203 public PortletPreferences fetchByPrimaryKey(long portletPreferencesId); 1204 1205 @Override 1206 public java.util.Map<java.io.Serializable, PortletPreferences> fetchByPrimaryKeys( 1207 java.util.Set<java.io.Serializable> primaryKeys); 1208 1209 /** 1210 * Returns all the portlet preferenceses. 1211 * 1212 * @return the portlet preferenceses 1213 */ 1214 public java.util.List<PortletPreferences> findAll(); 1215 1216 /** 1217 * Returns a range of all the portlet preferenceses. 1218 * 1219 * <p> 1220 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PortletPreferencesModelImpl}. 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. 1221 * </p> 1222 * 1223 * @param start the lower bound of the range of portlet preferenceses 1224 * @param end the upper bound of the range of portlet preferenceses (not inclusive) 1225 * @return the range of portlet preferenceses 1226 */ 1227 public java.util.List<PortletPreferences> findAll(int start, int end); 1228 1229 /** 1230 * Returns an ordered range of all the portlet preferenceses. 1231 * 1232 * <p> 1233 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PortletPreferencesModelImpl}. 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. 1234 * </p> 1235 * 1236 * @param start the lower bound of the range of portlet preferenceses 1237 * @param end the upper bound of the range of portlet preferenceses (not inclusive) 1238 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1239 * @return the ordered range of portlet preferenceses 1240 */ 1241 public java.util.List<PortletPreferences> findAll(int start, int end, 1242 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator); 1243 1244 /** 1245 * Returns an ordered range of all the portlet preferenceses. 1246 * 1247 * <p> 1248 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PortletPreferencesModelImpl}. 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. 1249 * </p> 1250 * 1251 * @param start the lower bound of the range of portlet preferenceses 1252 * @param end the upper bound of the range of portlet preferenceses (not inclusive) 1253 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1254 * @param retrieveFromCache whether to retrieve from the finder cache 1255 * @return the ordered range of portlet preferenceses 1256 */ 1257 public java.util.List<PortletPreferences> findAll(int start, int end, 1258 com.liferay.portal.kernel.util.OrderByComparator<PortletPreferences> orderByComparator, 1259 boolean retrieveFromCache); 1260 1261 /** 1262 * Removes all the portlet preferenceses from the database. 1263 */ 1264 public void removeAll(); 1265 1266 /** 1267 * Returns the number of portlet preferenceses. 1268 * 1269 * @return the number of portlet preferenceses 1270 */ 1271 public int countAll(); 1272 }