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