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