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