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 an ordered range of all the expando values where tableId = ?. 160 * 161 * <p> 162 * 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. 163 * </p> 164 * 165 * @param tableId the table ID 166 * @param start the lower bound of the range of expando values 167 * @param end the upper bound of the range of expando values (not inclusive) 168 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 169 * @param retrieveFromCache whether to retrieve from the finder cache 170 * @return the ordered range of matching expando values 171 */ 172 public static List<ExpandoValue> findByTableId(long tableId, int start, 173 int end, OrderByComparator<ExpandoValue> orderByComparator, 174 boolean retrieveFromCache) { 175 return getPersistence() 176 .findByTableId(tableId, start, end, orderByComparator, 177 retrieveFromCache); 178 } 179 180 /** 181 * Returns the first expando value in the ordered set where tableId = ?. 182 * 183 * @param tableId the table ID 184 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 185 * @return the first matching expando value 186 * @throws NoSuchValueException if a matching expando value could not be found 187 */ 188 public static ExpandoValue findByTableId_First(long tableId, 189 OrderByComparator<ExpandoValue> orderByComparator) 190 throws com.liferay.portlet.expando.exception.NoSuchValueException { 191 return getPersistence().findByTableId_First(tableId, orderByComparator); 192 } 193 194 /** 195 * Returns the first expando value in the ordered set where tableId = ?. 196 * 197 * @param tableId the table ID 198 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 199 * @return the first matching expando value, or <code>null</code> if a matching expando value could not be found 200 */ 201 public static ExpandoValue fetchByTableId_First(long tableId, 202 OrderByComparator<ExpandoValue> orderByComparator) { 203 return getPersistence().fetchByTableId_First(tableId, orderByComparator); 204 } 205 206 /** 207 * Returns the last expando value in the ordered set where tableId = ?. 208 * 209 * @param tableId the table ID 210 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 211 * @return the last matching expando value 212 * @throws NoSuchValueException if a matching expando value could not be found 213 */ 214 public static ExpandoValue findByTableId_Last(long tableId, 215 OrderByComparator<ExpandoValue> orderByComparator) 216 throws com.liferay.portlet.expando.exception.NoSuchValueException { 217 return getPersistence().findByTableId_Last(tableId, orderByComparator); 218 } 219 220 /** 221 * Returns the last expando value in the ordered set where tableId = ?. 222 * 223 * @param tableId the table ID 224 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 225 * @return the last matching expando value, or <code>null</code> if a matching expando value could not be found 226 */ 227 public static ExpandoValue fetchByTableId_Last(long tableId, 228 OrderByComparator<ExpandoValue> orderByComparator) { 229 return getPersistence().fetchByTableId_Last(tableId, orderByComparator); 230 } 231 232 /** 233 * Returns the expando values before and after the current expando value in the ordered set where tableId = ?. 234 * 235 * @param valueId the primary key of the current expando value 236 * @param tableId the table ID 237 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 238 * @return the previous, current, and next expando value 239 * @throws NoSuchValueException if a expando value with the primary key could not be found 240 */ 241 public static ExpandoValue[] findByTableId_PrevAndNext(long valueId, 242 long tableId, OrderByComparator<ExpandoValue> orderByComparator) 243 throws com.liferay.portlet.expando.exception.NoSuchValueException { 244 return getPersistence() 245 .findByTableId_PrevAndNext(valueId, tableId, 246 orderByComparator); 247 } 248 249 /** 250 * Removes all the expando values where tableId = ? from the database. 251 * 252 * @param tableId the table ID 253 */ 254 public static void removeByTableId(long tableId) { 255 getPersistence().removeByTableId(tableId); 256 } 257 258 /** 259 * Returns the number of expando values where tableId = ?. 260 * 261 * @param tableId the table ID 262 * @return the number of matching expando values 263 */ 264 public static int countByTableId(long tableId) { 265 return getPersistence().countByTableId(tableId); 266 } 267 268 /** 269 * Returns all the expando values where columnId = ?. 270 * 271 * @param columnId the column ID 272 * @return the matching expando values 273 */ 274 public static List<ExpandoValue> findByColumnId(long columnId) { 275 return getPersistence().findByColumnId(columnId); 276 } 277 278 /** 279 * Returns a range of all the expando values where columnId = ?. 280 * 281 * <p> 282 * 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. 283 * </p> 284 * 285 * @param columnId the column ID 286 * @param start the lower bound of the range of expando values 287 * @param end the upper bound of the range of expando values (not inclusive) 288 * @return the range of matching expando values 289 */ 290 public static List<ExpandoValue> findByColumnId(long columnId, int start, 291 int end) { 292 return getPersistence().findByColumnId(columnId, start, end); 293 } 294 295 /** 296 * Returns an ordered range of all the expando values where columnId = ?. 297 * 298 * <p> 299 * 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. 300 * </p> 301 * 302 * @param columnId the column ID 303 * @param start the lower bound of the range of expando values 304 * @param end the upper bound of the range of expando values (not inclusive) 305 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 306 * @return the ordered range of matching expando values 307 */ 308 public static List<ExpandoValue> findByColumnId(long columnId, int start, 309 int end, OrderByComparator<ExpandoValue> orderByComparator) { 310 return getPersistence() 311 .findByColumnId(columnId, start, end, orderByComparator); 312 } 313 314 /** 315 * Returns an ordered range of all the expando values where columnId = ?. 316 * 317 * <p> 318 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ExpandoValueModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 319 * </p> 320 * 321 * @param columnId the column ID 322 * @param start the lower bound of the range of expando values 323 * @param end the upper bound of the range of expando values (not inclusive) 324 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 325 * @param retrieveFromCache whether to retrieve from the finder cache 326 * @return the ordered range of matching expando values 327 */ 328 public static List<ExpandoValue> findByColumnId(long columnId, int start, 329 int end, OrderByComparator<ExpandoValue> orderByComparator, 330 boolean retrieveFromCache) { 331 return getPersistence() 332 .findByColumnId(columnId, start, end, orderByComparator, 333 retrieveFromCache); 334 } 335 336 /** 337 * Returns the first expando value in the ordered set where columnId = ?. 338 * 339 * @param columnId the column ID 340 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 341 * @return the first matching expando value 342 * @throws NoSuchValueException if a matching expando value could not be found 343 */ 344 public static ExpandoValue findByColumnId_First(long columnId, 345 OrderByComparator<ExpandoValue> orderByComparator) 346 throws com.liferay.portlet.expando.exception.NoSuchValueException { 347 return getPersistence().findByColumnId_First(columnId, orderByComparator); 348 } 349 350 /** 351 * Returns the first expando value in the ordered set where columnId = ?. 352 * 353 * @param columnId the column ID 354 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 355 * @return the first matching expando value, or <code>null</code> if a matching expando value could not be found 356 */ 357 public static ExpandoValue fetchByColumnId_First(long columnId, 358 OrderByComparator<ExpandoValue> orderByComparator) { 359 return getPersistence() 360 .fetchByColumnId_First(columnId, orderByComparator); 361 } 362 363 /** 364 * Returns the last expando value in the ordered set where columnId = ?. 365 * 366 * @param columnId the column ID 367 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 368 * @return the last matching expando value 369 * @throws NoSuchValueException if a matching expando value could not be found 370 */ 371 public static ExpandoValue findByColumnId_Last(long columnId, 372 OrderByComparator<ExpandoValue> orderByComparator) 373 throws com.liferay.portlet.expando.exception.NoSuchValueException { 374 return getPersistence().findByColumnId_Last(columnId, orderByComparator); 375 } 376 377 /** 378 * Returns the last expando value in the ordered set where columnId = ?. 379 * 380 * @param columnId the column ID 381 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 382 * @return the last matching expando value, or <code>null</code> if a matching expando value could not be found 383 */ 384 public static ExpandoValue fetchByColumnId_Last(long columnId, 385 OrderByComparator<ExpandoValue> orderByComparator) { 386 return getPersistence().fetchByColumnId_Last(columnId, orderByComparator); 387 } 388 389 /** 390 * Returns the expando values before and after the current expando value in the ordered set where columnId = ?. 391 * 392 * @param valueId the primary key of the current expando value 393 * @param columnId the column ID 394 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 395 * @return the previous, current, and next expando value 396 * @throws NoSuchValueException if a expando value with the primary key could not be found 397 */ 398 public static ExpandoValue[] findByColumnId_PrevAndNext(long valueId, 399 long columnId, OrderByComparator<ExpandoValue> orderByComparator) 400 throws com.liferay.portlet.expando.exception.NoSuchValueException { 401 return getPersistence() 402 .findByColumnId_PrevAndNext(valueId, columnId, 403 orderByComparator); 404 } 405 406 /** 407 * Removes all the expando values where columnId = ? from the database. 408 * 409 * @param columnId the column ID 410 */ 411 public static void removeByColumnId(long columnId) { 412 getPersistence().removeByColumnId(columnId); 413 } 414 415 /** 416 * Returns the number of expando values where columnId = ?. 417 * 418 * @param columnId the column ID 419 * @return the number of matching expando values 420 */ 421 public static int countByColumnId(long columnId) { 422 return getPersistence().countByColumnId(columnId); 423 } 424 425 /** 426 * Returns all the expando values where rowId = ?. 427 * 428 * @param rowId the row ID 429 * @return the matching expando values 430 */ 431 public static List<ExpandoValue> findByRowId(long rowId) { 432 return getPersistence().findByRowId(rowId); 433 } 434 435 /** 436 * Returns a range of all the expando values where rowId = ?. 437 * 438 * <p> 439 * 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. 440 * </p> 441 * 442 * @param rowId the row ID 443 * @param start the lower bound of the range of expando values 444 * @param end the upper bound of the range of expando values (not inclusive) 445 * @return the range of matching expando values 446 */ 447 public static List<ExpandoValue> findByRowId(long rowId, int start, int end) { 448 return getPersistence().findByRowId(rowId, start, end); 449 } 450 451 /** 452 * Returns an ordered range of all the expando values where rowId = ?. 453 * 454 * <p> 455 * 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. 456 * </p> 457 * 458 * @param rowId the row ID 459 * @param start the lower bound of the range of expando values 460 * @param end the upper bound of the range of expando values (not inclusive) 461 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 462 * @return the ordered range of matching expando values 463 */ 464 public static List<ExpandoValue> findByRowId(long rowId, int start, 465 int end, OrderByComparator<ExpandoValue> orderByComparator) { 466 return getPersistence().findByRowId(rowId, start, end, orderByComparator); 467 } 468 469 /** 470 * Returns an ordered range of all the expando values where rowId = ?. 471 * 472 * <p> 473 * 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. 474 * </p> 475 * 476 * @param rowId the row ID 477 * @param start the lower bound of the range of expando values 478 * @param end the upper bound of the range of expando values (not inclusive) 479 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 480 * @param retrieveFromCache whether to retrieve from the finder cache 481 * @return the ordered range of matching expando values 482 */ 483 public static List<ExpandoValue> findByRowId(long rowId, int start, 484 int end, OrderByComparator<ExpandoValue> orderByComparator, 485 boolean retrieveFromCache) { 486 return getPersistence() 487 .findByRowId(rowId, start, end, orderByComparator, 488 retrieveFromCache); 489 } 490 491 /** 492 * Returns the first expando value in the ordered set where rowId = ?. 493 * 494 * @param rowId the row ID 495 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 496 * @return the first matching expando value 497 * @throws NoSuchValueException if a matching expando value could not be found 498 */ 499 public static ExpandoValue findByRowId_First(long rowId, 500 OrderByComparator<ExpandoValue> orderByComparator) 501 throws com.liferay.portlet.expando.exception.NoSuchValueException { 502 return getPersistence().findByRowId_First(rowId, orderByComparator); 503 } 504 505 /** 506 * Returns the first expando value in the ordered set where rowId = ?. 507 * 508 * @param rowId the row ID 509 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 510 * @return the first matching expando value, or <code>null</code> if a matching expando value could not be found 511 */ 512 public static ExpandoValue fetchByRowId_First(long rowId, 513 OrderByComparator<ExpandoValue> orderByComparator) { 514 return getPersistence().fetchByRowId_First(rowId, orderByComparator); 515 } 516 517 /** 518 * Returns the last expando value in the ordered set where rowId = ?. 519 * 520 * @param rowId the row ID 521 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 522 * @return the last matching expando value 523 * @throws NoSuchValueException if a matching expando value could not be found 524 */ 525 public static ExpandoValue findByRowId_Last(long rowId, 526 OrderByComparator<ExpandoValue> orderByComparator) 527 throws com.liferay.portlet.expando.exception.NoSuchValueException { 528 return getPersistence().findByRowId_Last(rowId, orderByComparator); 529 } 530 531 /** 532 * Returns the last expando value in the ordered set where rowId = ?. 533 * 534 * @param rowId the row ID 535 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 536 * @return the last matching expando value, or <code>null</code> if a matching expando value could not be found 537 */ 538 public static ExpandoValue fetchByRowId_Last(long rowId, 539 OrderByComparator<ExpandoValue> orderByComparator) { 540 return getPersistence().fetchByRowId_Last(rowId, orderByComparator); 541 } 542 543 /** 544 * Returns the expando values before and after the current expando value in the ordered set where rowId = ?. 545 * 546 * @param valueId the primary key of the current expando value 547 * @param rowId the row ID 548 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 549 * @return the previous, current, and next expando value 550 * @throws NoSuchValueException if a expando value with the primary key could not be found 551 */ 552 public static ExpandoValue[] findByRowId_PrevAndNext(long valueId, 553 long rowId, OrderByComparator<ExpandoValue> orderByComparator) 554 throws com.liferay.portlet.expando.exception.NoSuchValueException { 555 return getPersistence() 556 .findByRowId_PrevAndNext(valueId, rowId, orderByComparator); 557 } 558 559 /** 560 * Removes all the expando values where rowId = ? from the database. 561 * 562 * @param rowId the row ID 563 */ 564 public static void removeByRowId(long rowId) { 565 getPersistence().removeByRowId(rowId); 566 } 567 568 /** 569 * Returns the number of expando values where rowId = ?. 570 * 571 * @param rowId the row ID 572 * @return the number of matching expando values 573 */ 574 public static int countByRowId(long rowId) { 575 return getPersistence().countByRowId(rowId); 576 } 577 578 /** 579 * Returns all the expando values where tableId = ? and columnId = ?. 580 * 581 * @param tableId the table ID 582 * @param columnId the column ID 583 * @return the matching expando values 584 */ 585 public static List<ExpandoValue> findByT_C(long tableId, long columnId) { 586 return getPersistence().findByT_C(tableId, columnId); 587 } 588 589 /** 590 * Returns a range of all the expando values where tableId = ? and columnId = ?. 591 * 592 * <p> 593 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ExpandoValueModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 594 * </p> 595 * 596 * @param tableId the table ID 597 * @param columnId the column ID 598 * @param start the lower bound of the range of expando values 599 * @param end the upper bound of the range of expando values (not inclusive) 600 * @return the range of matching expando values 601 */ 602 public static List<ExpandoValue> findByT_C(long tableId, long columnId, 603 int start, int end) { 604 return getPersistence().findByT_C(tableId, columnId, start, end); 605 } 606 607 /** 608 * Returns an ordered range of all the expando values where tableId = ? and columnId = ?. 609 * 610 * <p> 611 * 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. 612 * </p> 613 * 614 * @param tableId the table ID 615 * @param columnId the column ID 616 * @param start the lower bound of the range of expando values 617 * @param end the upper bound of the range of expando values (not inclusive) 618 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 619 * @return the ordered range of matching expando values 620 */ 621 public static List<ExpandoValue> findByT_C(long tableId, long columnId, 622 int start, int end, OrderByComparator<ExpandoValue> orderByComparator) { 623 return getPersistence() 624 .findByT_C(tableId, columnId, start, end, orderByComparator); 625 } 626 627 /** 628 * Returns an ordered range of all the expando values where tableId = ? and columnId = ?. 629 * 630 * <p> 631 * 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. 632 * </p> 633 * 634 * @param tableId the table ID 635 * @param columnId the column ID 636 * @param start the lower bound of the range of expando values 637 * @param end the upper bound of the range of expando values (not inclusive) 638 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 639 * @param retrieveFromCache whether to retrieve from the finder cache 640 * @return the ordered range of matching expando values 641 */ 642 public static List<ExpandoValue> findByT_C(long tableId, long columnId, 643 int start, int end, OrderByComparator<ExpandoValue> orderByComparator, 644 boolean retrieveFromCache) { 645 return getPersistence() 646 .findByT_C(tableId, columnId, start, end, orderByComparator, 647 retrieveFromCache); 648 } 649 650 /** 651 * Returns the first expando value in the ordered set where tableId = ? and columnId = ?. 652 * 653 * @param tableId the table ID 654 * @param columnId the column ID 655 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 656 * @return the first matching expando value 657 * @throws NoSuchValueException if a matching expando value could not be found 658 */ 659 public static ExpandoValue findByT_C_First(long tableId, long columnId, 660 OrderByComparator<ExpandoValue> orderByComparator) 661 throws com.liferay.portlet.expando.exception.NoSuchValueException { 662 return getPersistence() 663 .findByT_C_First(tableId, columnId, orderByComparator); 664 } 665 666 /** 667 * Returns the first expando value in the ordered set where tableId = ? and columnId = ?. 668 * 669 * @param tableId the table ID 670 * @param columnId the column ID 671 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 672 * @return the first matching expando value, or <code>null</code> if a matching expando value could not be found 673 */ 674 public static ExpandoValue fetchByT_C_First(long tableId, long columnId, 675 OrderByComparator<ExpandoValue> orderByComparator) { 676 return getPersistence() 677 .fetchByT_C_First(tableId, columnId, orderByComparator); 678 } 679 680 /** 681 * Returns the last expando value in the ordered set where tableId = ? and columnId = ?. 682 * 683 * @param tableId the table ID 684 * @param columnId the column ID 685 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 686 * @return the last matching expando value 687 * @throws NoSuchValueException if a matching expando value could not be found 688 */ 689 public static ExpandoValue findByT_C_Last(long tableId, long columnId, 690 OrderByComparator<ExpandoValue> orderByComparator) 691 throws com.liferay.portlet.expando.exception.NoSuchValueException { 692 return getPersistence() 693 .findByT_C_Last(tableId, columnId, orderByComparator); 694 } 695 696 /** 697 * Returns the last expando value in the ordered set where tableId = ? and columnId = ?. 698 * 699 * @param tableId the table ID 700 * @param columnId the column ID 701 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 702 * @return the last matching expando value, or <code>null</code> if a matching expando value could not be found 703 */ 704 public static ExpandoValue fetchByT_C_Last(long tableId, long columnId, 705 OrderByComparator<ExpandoValue> orderByComparator) { 706 return getPersistence() 707 .fetchByT_C_Last(tableId, columnId, orderByComparator); 708 } 709 710 /** 711 * Returns the expando values before and after the current expando value in the ordered set where tableId = ? and columnId = ?. 712 * 713 * @param valueId the primary key of the current expando value 714 * @param tableId the table ID 715 * @param columnId the column ID 716 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 717 * @return the previous, current, and next expando value 718 * @throws NoSuchValueException if a expando value with the primary key could not be found 719 */ 720 public static ExpandoValue[] findByT_C_PrevAndNext(long valueId, 721 long tableId, long columnId, 722 OrderByComparator<ExpandoValue> orderByComparator) 723 throws com.liferay.portlet.expando.exception.NoSuchValueException { 724 return getPersistence() 725 .findByT_C_PrevAndNext(valueId, tableId, columnId, 726 orderByComparator); 727 } 728 729 /** 730 * Removes all the expando values where tableId = ? and columnId = ? from the database. 731 * 732 * @param tableId the table ID 733 * @param columnId the column ID 734 */ 735 public static void removeByT_C(long tableId, long columnId) { 736 getPersistence().removeByT_C(tableId, columnId); 737 } 738 739 /** 740 * Returns the number of expando values where tableId = ? and columnId = ?. 741 * 742 * @param tableId the table ID 743 * @param columnId the column ID 744 * @return the number of matching expando values 745 */ 746 public static int countByT_C(long tableId, long columnId) { 747 return getPersistence().countByT_C(tableId, columnId); 748 } 749 750 /** 751 * Returns all the expando values where tableId = ? and rowId = ?. 752 * 753 * @param tableId the table ID 754 * @param rowId the row ID 755 * @return the matching expando values 756 */ 757 public static List<ExpandoValue> findByT_R(long tableId, long rowId) { 758 return getPersistence().findByT_R(tableId, rowId); 759 } 760 761 /** 762 * Returns a range of all the expando values where tableId = ? and rowId = ?. 763 * 764 * <p> 765 * 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. 766 * </p> 767 * 768 * @param tableId the table ID 769 * @param rowId the row ID 770 * @param start the lower bound of the range of expando values 771 * @param end the upper bound of the range of expando values (not inclusive) 772 * @return the range of matching expando values 773 */ 774 public static List<ExpandoValue> findByT_R(long tableId, long rowId, 775 int start, int end) { 776 return getPersistence().findByT_R(tableId, rowId, start, end); 777 } 778 779 /** 780 * Returns an ordered range of all the expando values where tableId = ? and rowId = ?. 781 * 782 * <p> 783 * 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. 784 * </p> 785 * 786 * @param tableId the table ID 787 * @param rowId the row ID 788 * @param start the lower bound of the range of expando values 789 * @param end the upper bound of the range of expando values (not inclusive) 790 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 791 * @return the ordered range of matching expando values 792 */ 793 public static List<ExpandoValue> findByT_R(long tableId, long rowId, 794 int start, int end, OrderByComparator<ExpandoValue> orderByComparator) { 795 return getPersistence() 796 .findByT_R(tableId, rowId, start, end, orderByComparator); 797 } 798 799 /** 800 * Returns an ordered range of all the expando values where tableId = ? and rowId = ?. 801 * 802 * <p> 803 * 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. 804 * </p> 805 * 806 * @param tableId the table ID 807 * @param rowId the row ID 808 * @param start the lower bound of the range of expando values 809 * @param end the upper bound of the range of expando values (not inclusive) 810 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 811 * @param retrieveFromCache whether to retrieve from the finder cache 812 * @return the ordered range of matching expando values 813 */ 814 public static List<ExpandoValue> findByT_R(long tableId, long rowId, 815 int start, int end, OrderByComparator<ExpandoValue> orderByComparator, 816 boolean retrieveFromCache) { 817 return getPersistence() 818 .findByT_R(tableId, rowId, start, end, orderByComparator, 819 retrieveFromCache); 820 } 821 822 /** 823 * Returns the first expando value in the ordered set where tableId = ? and rowId = ?. 824 * 825 * @param tableId the table ID 826 * @param rowId the row ID 827 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 828 * @return the first matching expando value 829 * @throws NoSuchValueException if a matching expando value could not be found 830 */ 831 public static ExpandoValue findByT_R_First(long tableId, long rowId, 832 OrderByComparator<ExpandoValue> orderByComparator) 833 throws com.liferay.portlet.expando.exception.NoSuchValueException { 834 return getPersistence() 835 .findByT_R_First(tableId, rowId, orderByComparator); 836 } 837 838 /** 839 * Returns the first expando value in the ordered set where tableId = ? and rowId = ?. 840 * 841 * @param tableId the table ID 842 * @param rowId the row ID 843 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 844 * @return the first matching expando value, or <code>null</code> if a matching expando value could not be found 845 */ 846 public static ExpandoValue fetchByT_R_First(long tableId, long rowId, 847 OrderByComparator<ExpandoValue> orderByComparator) { 848 return getPersistence() 849 .fetchByT_R_First(tableId, rowId, orderByComparator); 850 } 851 852 /** 853 * Returns the last expando value in the ordered set where tableId = ? and rowId = ?. 854 * 855 * @param tableId the table ID 856 * @param rowId the row ID 857 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 858 * @return the last matching expando value 859 * @throws NoSuchValueException if a matching expando value could not be found 860 */ 861 public static ExpandoValue findByT_R_Last(long tableId, long rowId, 862 OrderByComparator<ExpandoValue> orderByComparator) 863 throws com.liferay.portlet.expando.exception.NoSuchValueException { 864 return getPersistence().findByT_R_Last(tableId, rowId, orderByComparator); 865 } 866 867 /** 868 * Returns the last expando value in the ordered set where tableId = ? and rowId = ?. 869 * 870 * @param tableId the table ID 871 * @param rowId the row ID 872 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 873 * @return the last matching expando value, or <code>null</code> if a matching expando value could not be found 874 */ 875 public static ExpandoValue fetchByT_R_Last(long tableId, long rowId, 876 OrderByComparator<ExpandoValue> orderByComparator) { 877 return getPersistence() 878 .fetchByT_R_Last(tableId, rowId, orderByComparator); 879 } 880 881 /** 882 * Returns the expando values before and after the current expando value in the ordered set where tableId = ? and rowId = ?. 883 * 884 * @param valueId the primary key of the current expando value 885 * @param tableId the table ID 886 * @param rowId the row ID 887 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 888 * @return the previous, current, and next expando value 889 * @throws NoSuchValueException if a expando value with the primary key could not be found 890 */ 891 public static ExpandoValue[] findByT_R_PrevAndNext(long valueId, 892 long tableId, long rowId, 893 OrderByComparator<ExpandoValue> orderByComparator) 894 throws com.liferay.portlet.expando.exception.NoSuchValueException { 895 return getPersistence() 896 .findByT_R_PrevAndNext(valueId, tableId, rowId, 897 orderByComparator); 898 } 899 900 /** 901 * Removes all the expando values where tableId = ? and rowId = ? from the database. 902 * 903 * @param tableId the table ID 904 * @param rowId the row ID 905 */ 906 public static void removeByT_R(long tableId, long rowId) { 907 getPersistence().removeByT_R(tableId, rowId); 908 } 909 910 /** 911 * Returns the number of expando values where tableId = ? and rowId = ?. 912 * 913 * @param tableId the table ID 914 * @param rowId the row ID 915 * @return the number of matching expando values 916 */ 917 public static int countByT_R(long tableId, long rowId) { 918 return getPersistence().countByT_R(tableId, rowId); 919 } 920 921 /** 922 * Returns all the expando values where tableId = ? and classPK = ?. 923 * 924 * @param tableId the table ID 925 * @param classPK the class p k 926 * @return the matching expando values 927 */ 928 public static List<ExpandoValue> findByT_CPK(long tableId, long classPK) { 929 return getPersistence().findByT_CPK(tableId, classPK); 930 } 931 932 /** 933 * Returns a range of all the expando values where tableId = ? and classPK = ?. 934 * 935 * <p> 936 * 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. 937 * </p> 938 * 939 * @param tableId the table ID 940 * @param classPK the class p k 941 * @param start the lower bound of the range of expando values 942 * @param end the upper bound of the range of expando values (not inclusive) 943 * @return the range of matching expando values 944 */ 945 public static List<ExpandoValue> findByT_CPK(long tableId, long classPK, 946 int start, int end) { 947 return getPersistence().findByT_CPK(tableId, classPK, start, end); 948 } 949 950 /** 951 * Returns an ordered range of all the expando values where tableId = ? and classPK = ?. 952 * 953 * <p> 954 * 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. 955 * </p> 956 * 957 * @param tableId the table ID 958 * @param classPK the class p k 959 * @param start the lower bound of the range of expando values 960 * @param end the upper bound of the range of expando values (not inclusive) 961 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 962 * @return the ordered range of matching expando values 963 */ 964 public static List<ExpandoValue> findByT_CPK(long tableId, long classPK, 965 int start, int end, OrderByComparator<ExpandoValue> orderByComparator) { 966 return getPersistence() 967 .findByT_CPK(tableId, classPK, start, end, orderByComparator); 968 } 969 970 /** 971 * Returns an ordered range of all the expando values where tableId = ? and classPK = ?. 972 * 973 * <p> 974 * 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. 975 * </p> 976 * 977 * @param tableId the table ID 978 * @param classPK the class p k 979 * @param start the lower bound of the range of expando values 980 * @param end the upper bound of the range of expando values (not inclusive) 981 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 982 * @param retrieveFromCache whether to retrieve from the finder cache 983 * @return the ordered range of matching expando values 984 */ 985 public static List<ExpandoValue> findByT_CPK(long tableId, long classPK, 986 int start, int end, OrderByComparator<ExpandoValue> orderByComparator, 987 boolean retrieveFromCache) { 988 return getPersistence() 989 .findByT_CPK(tableId, classPK, start, end, 990 orderByComparator, retrieveFromCache); 991 } 992 993 /** 994 * Returns the first expando value in the ordered set where tableId = ? and classPK = ?. 995 * 996 * @param tableId the table 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 1000 * @throws NoSuchValueException if a matching expando value could not be found 1001 */ 1002 public static ExpandoValue findByT_CPK_First(long tableId, long classPK, 1003 OrderByComparator<ExpandoValue> orderByComparator) 1004 throws com.liferay.portlet.expando.exception.NoSuchValueException { 1005 return getPersistence() 1006 .findByT_CPK_First(tableId, classPK, orderByComparator); 1007 } 1008 1009 /** 1010 * Returns the first expando value in the ordered set where tableId = ? and classPK = ?. 1011 * 1012 * @param tableId the table ID 1013 * @param classPK the class p k 1014 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1015 * @return the first matching expando value, or <code>null</code> if a matching expando value could not be found 1016 */ 1017 public static ExpandoValue fetchByT_CPK_First(long tableId, long classPK, 1018 OrderByComparator<ExpandoValue> orderByComparator) { 1019 return getPersistence() 1020 .fetchByT_CPK_First(tableId, classPK, orderByComparator); 1021 } 1022 1023 /** 1024 * Returns the last expando value in the ordered set where tableId = ? and classPK = ?. 1025 * 1026 * @param tableId the table ID 1027 * @param classPK the class p k 1028 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1029 * @return the last matching expando value 1030 * @throws NoSuchValueException if a matching expando value could not be found 1031 */ 1032 public static ExpandoValue findByT_CPK_Last(long tableId, long classPK, 1033 OrderByComparator<ExpandoValue> orderByComparator) 1034 throws com.liferay.portlet.expando.exception.NoSuchValueException { 1035 return getPersistence() 1036 .findByT_CPK_Last(tableId, classPK, orderByComparator); 1037 } 1038 1039 /** 1040 * Returns the last expando value in the ordered set where tableId = ? and classPK = ?. 1041 * 1042 * @param tableId the table ID 1043 * @param classPK the class p k 1044 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1045 * @return the last matching expando value, or <code>null</code> if a matching expando value could not be found 1046 */ 1047 public static ExpandoValue fetchByT_CPK_Last(long tableId, long classPK, 1048 OrderByComparator<ExpandoValue> orderByComparator) { 1049 return getPersistence() 1050 .fetchByT_CPK_Last(tableId, classPK, orderByComparator); 1051 } 1052 1053 /** 1054 * Returns the expando values before and after the current expando value in the ordered set where tableId = ? and classPK = ?. 1055 * 1056 * @param valueId the primary key of the current expando value 1057 * @param tableId the table ID 1058 * @param classPK the class p k 1059 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1060 * @return the previous, current, and next expando value 1061 * @throws NoSuchValueException if a expando value with the primary key could not be found 1062 */ 1063 public static ExpandoValue[] findByT_CPK_PrevAndNext(long valueId, 1064 long tableId, long classPK, 1065 OrderByComparator<ExpandoValue> orderByComparator) 1066 throws com.liferay.portlet.expando.exception.NoSuchValueException { 1067 return getPersistence() 1068 .findByT_CPK_PrevAndNext(valueId, tableId, classPK, 1069 orderByComparator); 1070 } 1071 1072 /** 1073 * Removes all the expando values where tableId = ? and classPK = ? from the database. 1074 * 1075 * @param tableId the table ID 1076 * @param classPK the class p k 1077 */ 1078 public static void removeByT_CPK(long tableId, long classPK) { 1079 getPersistence().removeByT_CPK(tableId, classPK); 1080 } 1081 1082 /** 1083 * Returns the number of expando values where tableId = ? and classPK = ?. 1084 * 1085 * @param tableId the table ID 1086 * @param classPK the class p k 1087 * @return the number of matching expando values 1088 */ 1089 public static int countByT_CPK(long tableId, long classPK) { 1090 return getPersistence().countByT_CPK(tableId, classPK); 1091 } 1092 1093 /** 1094 * Returns the expando value where columnId = ? and rowId = ? or throws a {@link NoSuchValueException} if it could not be found. 1095 * 1096 * @param columnId the column ID 1097 * @param rowId the row ID 1098 * @return the matching expando value 1099 * @throws NoSuchValueException if a matching expando value could not be found 1100 */ 1101 public static ExpandoValue findByC_R(long columnId, long rowId) 1102 throws com.liferay.portlet.expando.exception.NoSuchValueException { 1103 return getPersistence().findByC_R(columnId, rowId); 1104 } 1105 1106 /** 1107 * Returns the expando value where columnId = ? and rowId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1108 * 1109 * @param columnId the column ID 1110 * @param rowId the row ID 1111 * @return the matching expando value, or <code>null</code> if a matching expando value could not be found 1112 */ 1113 public static ExpandoValue fetchByC_R(long columnId, long rowId) { 1114 return getPersistence().fetchByC_R(columnId, rowId); 1115 } 1116 1117 /** 1118 * Returns the expando value where columnId = ? and rowId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 1119 * 1120 * @param columnId the column ID 1121 * @param rowId the row ID 1122 * @param retrieveFromCache whether to retrieve from the finder cache 1123 * @return the matching expando value, or <code>null</code> if a matching expando value could not be found 1124 */ 1125 public static ExpandoValue fetchByC_R(long columnId, long rowId, 1126 boolean retrieveFromCache) { 1127 return getPersistence().fetchByC_R(columnId, rowId, retrieveFromCache); 1128 } 1129 1130 /** 1131 * Removes the expando value where columnId = ? and rowId = ? from the database. 1132 * 1133 * @param columnId the column ID 1134 * @param rowId the row ID 1135 * @return the expando value that was removed 1136 */ 1137 public static ExpandoValue removeByC_R(long columnId, long rowId) 1138 throws com.liferay.portlet.expando.exception.NoSuchValueException { 1139 return getPersistence().removeByC_R(columnId, rowId); 1140 } 1141 1142 /** 1143 * Returns the number of expando values where columnId = ? and rowId = ?. 1144 * 1145 * @param columnId the column ID 1146 * @param rowId the row ID 1147 * @return the number of matching expando values 1148 */ 1149 public static int countByC_R(long columnId, long rowId) { 1150 return getPersistence().countByC_R(columnId, rowId); 1151 } 1152 1153 /** 1154 * Returns all the expando values where classNameId = ? and classPK = ?. 1155 * 1156 * @param classNameId the class name ID 1157 * @param classPK the class p k 1158 * @return the matching expando values 1159 */ 1160 public static List<ExpandoValue> findByC_C(long classNameId, long classPK) { 1161 return getPersistence().findByC_C(classNameId, classPK); 1162 } 1163 1164 /** 1165 * Returns a range of all the expando values where classNameId = ? and classPK = ?. 1166 * 1167 * <p> 1168 * 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. 1169 * </p> 1170 * 1171 * @param classNameId the class name ID 1172 * @param classPK the class p k 1173 * @param start the lower bound of the range of expando values 1174 * @param end the upper bound of the range of expando values (not inclusive) 1175 * @return the range of matching expando values 1176 */ 1177 public static List<ExpandoValue> findByC_C(long classNameId, long classPK, 1178 int start, int end) { 1179 return getPersistence().findByC_C(classNameId, classPK, start, end); 1180 } 1181 1182 /** 1183 * Returns an ordered range of all the expando values where classNameId = ? and classPK = ?. 1184 * 1185 * <p> 1186 * 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. 1187 * </p> 1188 * 1189 * @param classNameId the class name ID 1190 * @param classPK the class p k 1191 * @param start the lower bound of the range of expando values 1192 * @param end the upper bound of the range of expando values (not inclusive) 1193 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1194 * @return the ordered range of matching expando values 1195 */ 1196 public static List<ExpandoValue> findByC_C(long classNameId, long classPK, 1197 int start, int end, OrderByComparator<ExpandoValue> orderByComparator) { 1198 return getPersistence() 1199 .findByC_C(classNameId, classPK, start, end, 1200 orderByComparator); 1201 } 1202 1203 /** 1204 * Returns an ordered range of all the expando values where classNameId = ? and classPK = ?. 1205 * 1206 * <p> 1207 * 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. 1208 * </p> 1209 * 1210 * @param classNameId the class name ID 1211 * @param classPK the class p k 1212 * @param start the lower bound of the range of expando values 1213 * @param end the upper bound of the range of expando values (not inclusive) 1214 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1215 * @param retrieveFromCache whether to retrieve from the finder cache 1216 * @return the ordered range of matching expando values 1217 */ 1218 public static List<ExpandoValue> findByC_C(long classNameId, long classPK, 1219 int start, int end, OrderByComparator<ExpandoValue> orderByComparator, 1220 boolean retrieveFromCache) { 1221 return getPersistence() 1222 .findByC_C(classNameId, classPK, start, end, 1223 orderByComparator, retrieveFromCache); 1224 } 1225 1226 /** 1227 * Returns the first expando value in the ordered set where classNameId = ? and classPK = ?. 1228 * 1229 * @param classNameId the class name ID 1230 * @param classPK the class p k 1231 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1232 * @return the first matching expando value 1233 * @throws NoSuchValueException if a matching expando value could not be found 1234 */ 1235 public static ExpandoValue findByC_C_First(long classNameId, long classPK, 1236 OrderByComparator<ExpandoValue> orderByComparator) 1237 throws com.liferay.portlet.expando.exception.NoSuchValueException { 1238 return getPersistence() 1239 .findByC_C_First(classNameId, classPK, orderByComparator); 1240 } 1241 1242 /** 1243 * Returns the first expando value in the ordered set where classNameId = ? and classPK = ?. 1244 * 1245 * @param classNameId the class name ID 1246 * @param classPK the class p k 1247 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1248 * @return the first matching expando value, or <code>null</code> if a matching expando value could not be found 1249 */ 1250 public static ExpandoValue fetchByC_C_First(long classNameId, long classPK, 1251 OrderByComparator<ExpandoValue> orderByComparator) { 1252 return getPersistence() 1253 .fetchByC_C_First(classNameId, classPK, orderByComparator); 1254 } 1255 1256 /** 1257 * Returns the last expando value in the ordered set where classNameId = ? and classPK = ?. 1258 * 1259 * @param classNameId the class name ID 1260 * @param classPK the class p k 1261 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1262 * @return the last matching expando value 1263 * @throws NoSuchValueException if a matching expando value could not be found 1264 */ 1265 public static ExpandoValue findByC_C_Last(long classNameId, long classPK, 1266 OrderByComparator<ExpandoValue> orderByComparator) 1267 throws com.liferay.portlet.expando.exception.NoSuchValueException { 1268 return getPersistence() 1269 .findByC_C_Last(classNameId, classPK, orderByComparator); 1270 } 1271 1272 /** 1273 * Returns the last expando value in the ordered set where classNameId = ? and classPK = ?. 1274 * 1275 * @param classNameId the class name ID 1276 * @param classPK the class p k 1277 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1278 * @return the last matching expando value, or <code>null</code> if a matching expando value could not be found 1279 */ 1280 public static ExpandoValue fetchByC_C_Last(long classNameId, long classPK, 1281 OrderByComparator<ExpandoValue> orderByComparator) { 1282 return getPersistence() 1283 .fetchByC_C_Last(classNameId, classPK, orderByComparator); 1284 } 1285 1286 /** 1287 * Returns the expando values before and after the current expando value in the ordered set where classNameId = ? and classPK = ?. 1288 * 1289 * @param valueId the primary key of the current expando value 1290 * @param classNameId the class name ID 1291 * @param classPK the class p k 1292 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1293 * @return the previous, current, and next expando value 1294 * @throws NoSuchValueException if a expando value with the primary key could not be found 1295 */ 1296 public static ExpandoValue[] findByC_C_PrevAndNext(long valueId, 1297 long classNameId, long classPK, 1298 OrderByComparator<ExpandoValue> orderByComparator) 1299 throws com.liferay.portlet.expando.exception.NoSuchValueException { 1300 return getPersistence() 1301 .findByC_C_PrevAndNext(valueId, classNameId, classPK, 1302 orderByComparator); 1303 } 1304 1305 /** 1306 * Removes all the expando values where classNameId = ? and classPK = ? from the database. 1307 * 1308 * @param classNameId the class name ID 1309 * @param classPK the class p k 1310 */ 1311 public static void removeByC_C(long classNameId, long classPK) { 1312 getPersistence().removeByC_C(classNameId, classPK); 1313 } 1314 1315 /** 1316 * Returns the number of expando values where classNameId = ? and classPK = ?. 1317 * 1318 * @param classNameId the class name ID 1319 * @param classPK the class p k 1320 * @return the number of matching expando values 1321 */ 1322 public static int countByC_C(long classNameId, long classPK) { 1323 return getPersistence().countByC_C(classNameId, classPK); 1324 } 1325 1326 /** 1327 * Returns the expando value where tableId = ? and columnId = ? and classPK = ? or throws a {@link NoSuchValueException} if it could not be found. 1328 * 1329 * @param tableId the table ID 1330 * @param columnId the column ID 1331 * @param classPK the class p k 1332 * @return the matching expando value 1333 * @throws NoSuchValueException if a matching expando value could not be found 1334 */ 1335 public static ExpandoValue findByT_C_C(long tableId, long columnId, 1336 long classPK) 1337 throws com.liferay.portlet.expando.exception.NoSuchValueException { 1338 return getPersistence().findByT_C_C(tableId, columnId, classPK); 1339 } 1340 1341 /** 1342 * 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. 1343 * 1344 * @param tableId the table ID 1345 * @param columnId the column ID 1346 * @param classPK the class p k 1347 * @return the matching expando value, or <code>null</code> if a matching expando value could not be found 1348 */ 1349 public static ExpandoValue fetchByT_C_C(long tableId, long columnId, 1350 long classPK) { 1351 return getPersistence().fetchByT_C_C(tableId, columnId, classPK); 1352 } 1353 1354 /** 1355 * 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. 1356 * 1357 * @param tableId the table ID 1358 * @param columnId the column ID 1359 * @param classPK the class p k 1360 * @param retrieveFromCache whether to retrieve from the finder cache 1361 * @return the matching expando value, or <code>null</code> if a matching expando value could not be found 1362 */ 1363 public static ExpandoValue fetchByT_C_C(long tableId, long columnId, 1364 long classPK, boolean retrieveFromCache) { 1365 return getPersistence() 1366 .fetchByT_C_C(tableId, columnId, classPK, retrieveFromCache); 1367 } 1368 1369 /** 1370 * Removes the expando value where tableId = ? and columnId = ? and classPK = ? from the database. 1371 * 1372 * @param tableId the table ID 1373 * @param columnId the column ID 1374 * @param classPK the class p k 1375 * @return the expando value that was removed 1376 */ 1377 public static ExpandoValue removeByT_C_C(long tableId, long columnId, 1378 long classPK) 1379 throws com.liferay.portlet.expando.exception.NoSuchValueException { 1380 return getPersistence().removeByT_C_C(tableId, columnId, classPK); 1381 } 1382 1383 /** 1384 * Returns the number of expando values where tableId = ? and columnId = ? and classPK = ?. 1385 * 1386 * @param tableId the table ID 1387 * @param columnId the column ID 1388 * @param classPK the class p k 1389 * @return the number of matching expando values 1390 */ 1391 public static int countByT_C_C(long tableId, long columnId, long classPK) { 1392 return getPersistence().countByT_C_C(tableId, columnId, classPK); 1393 } 1394 1395 /** 1396 * Returns all the expando values where tableId = ? and columnId = ? and data = ?. 1397 * 1398 * @param tableId the table ID 1399 * @param columnId the column ID 1400 * @param data the data 1401 * @return the matching expando values 1402 */ 1403 public static List<ExpandoValue> findByT_C_D(long tableId, long columnId, 1404 java.lang.String data) { 1405 return getPersistence().findByT_C_D(tableId, columnId, data); 1406 } 1407 1408 /** 1409 * Returns a range of all the expando values where tableId = ? and columnId = ? and data = ?. 1410 * 1411 * <p> 1412 * 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. 1413 * </p> 1414 * 1415 * @param tableId the table ID 1416 * @param columnId the column ID 1417 * @param data the data 1418 * @param start the lower bound of the range of expando values 1419 * @param end the upper bound of the range of expando values (not inclusive) 1420 * @return the range of matching expando values 1421 */ 1422 public static List<ExpandoValue> findByT_C_D(long tableId, long columnId, 1423 java.lang.String data, int start, int end) { 1424 return getPersistence().findByT_C_D(tableId, columnId, data, start, end); 1425 } 1426 1427 /** 1428 * Returns an ordered range of all the expando values where tableId = ? and columnId = ? and data = ?. 1429 * 1430 * <p> 1431 * 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. 1432 * </p> 1433 * 1434 * @param tableId the table ID 1435 * @param columnId the column ID 1436 * @param data the data 1437 * @param start the lower bound of the range of expando values 1438 * @param end the upper bound of the range of expando values (not inclusive) 1439 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1440 * @return the ordered range of matching expando values 1441 */ 1442 public static List<ExpandoValue> findByT_C_D(long tableId, long columnId, 1443 java.lang.String data, int start, int end, 1444 OrderByComparator<ExpandoValue> orderByComparator) { 1445 return getPersistence() 1446 .findByT_C_D(tableId, columnId, data, start, end, 1447 orderByComparator); 1448 } 1449 1450 /** 1451 * Returns an ordered range of all the expando values where tableId = ? and columnId = ? and data = ?. 1452 * 1453 * <p> 1454 * 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. 1455 * </p> 1456 * 1457 * @param tableId the table ID 1458 * @param columnId the column ID 1459 * @param data the data 1460 * @param start the lower bound of the range of expando values 1461 * @param end the upper bound of the range of expando values (not inclusive) 1462 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1463 * @param retrieveFromCache whether to retrieve from the finder cache 1464 * @return the ordered range of matching expando values 1465 */ 1466 public static List<ExpandoValue> findByT_C_D(long tableId, long columnId, 1467 java.lang.String data, int start, int end, 1468 OrderByComparator<ExpandoValue> orderByComparator, 1469 boolean retrieveFromCache) { 1470 return getPersistence() 1471 .findByT_C_D(tableId, columnId, data, start, end, 1472 orderByComparator, retrieveFromCache); 1473 } 1474 1475 /** 1476 * Returns the first expando value in the ordered set where tableId = ? and columnId = ? and data = ?. 1477 * 1478 * @param tableId the table ID 1479 * @param columnId the column ID 1480 * @param data the data 1481 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1482 * @return the first matching expando value 1483 * @throws NoSuchValueException if a matching expando value could not be found 1484 */ 1485 public static ExpandoValue findByT_C_D_First(long tableId, long columnId, 1486 java.lang.String data, OrderByComparator<ExpandoValue> orderByComparator) 1487 throws com.liferay.portlet.expando.exception.NoSuchValueException { 1488 return getPersistence() 1489 .findByT_C_D_First(tableId, columnId, data, orderByComparator); 1490 } 1491 1492 /** 1493 * Returns the first expando value in the ordered set where tableId = ? and columnId = ? and data = ?. 1494 * 1495 * @param tableId the table ID 1496 * @param columnId the column ID 1497 * @param data the data 1498 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1499 * @return the first matching expando value, or <code>null</code> if a matching expando value could not be found 1500 */ 1501 public static ExpandoValue fetchByT_C_D_First(long tableId, long columnId, 1502 java.lang.String data, OrderByComparator<ExpandoValue> orderByComparator) { 1503 return getPersistence() 1504 .fetchByT_C_D_First(tableId, columnId, data, 1505 orderByComparator); 1506 } 1507 1508 /** 1509 * Returns the last expando value in the ordered set where tableId = ? and columnId = ? and data = ?. 1510 * 1511 * @param tableId the table ID 1512 * @param columnId the column ID 1513 * @param data the data 1514 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1515 * @return the last matching expando value 1516 * @throws NoSuchValueException if a matching expando value could not be found 1517 */ 1518 public static ExpandoValue findByT_C_D_Last(long tableId, long columnId, 1519 java.lang.String data, OrderByComparator<ExpandoValue> orderByComparator) 1520 throws com.liferay.portlet.expando.exception.NoSuchValueException { 1521 return getPersistence() 1522 .findByT_C_D_Last(tableId, columnId, data, orderByComparator); 1523 } 1524 1525 /** 1526 * Returns the last expando value in the ordered set where tableId = ? and columnId = ? and data = ?. 1527 * 1528 * @param tableId the table ID 1529 * @param columnId the column ID 1530 * @param data the data 1531 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1532 * @return the last matching expando value, or <code>null</code> if a matching expando value could not be found 1533 */ 1534 public static ExpandoValue fetchByT_C_D_Last(long tableId, long columnId, 1535 java.lang.String data, OrderByComparator<ExpandoValue> orderByComparator) { 1536 return getPersistence() 1537 .fetchByT_C_D_Last(tableId, columnId, data, orderByComparator); 1538 } 1539 1540 /** 1541 * Returns the expando values before and after the current expando value in the ordered set where tableId = ? and columnId = ? and data = ?. 1542 * 1543 * @param valueId the primary key of the current expando value 1544 * @param tableId the table ID 1545 * @param columnId the column ID 1546 * @param data the data 1547 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1548 * @return the previous, current, and next expando value 1549 * @throws NoSuchValueException if a expando value with the primary key could not be found 1550 */ 1551 public static ExpandoValue[] findByT_C_D_PrevAndNext(long valueId, 1552 long tableId, long columnId, java.lang.String data, 1553 OrderByComparator<ExpandoValue> orderByComparator) 1554 throws com.liferay.portlet.expando.exception.NoSuchValueException { 1555 return getPersistence() 1556 .findByT_C_D_PrevAndNext(valueId, tableId, columnId, data, 1557 orderByComparator); 1558 } 1559 1560 /** 1561 * Removes all the expando values where tableId = ? and columnId = ? and data = ? from the database. 1562 * 1563 * @param tableId the table ID 1564 * @param columnId the column ID 1565 * @param data the data 1566 */ 1567 public static void removeByT_C_D(long tableId, long columnId, 1568 java.lang.String data) { 1569 getPersistence().removeByT_C_D(tableId, columnId, data); 1570 } 1571 1572 /** 1573 * Returns the number of expando values where tableId = ? and columnId = ? and data = ?. 1574 * 1575 * @param tableId the table ID 1576 * @param columnId the column ID 1577 * @param data the data 1578 * @return the number of matching expando values 1579 */ 1580 public static int countByT_C_D(long tableId, long columnId, 1581 java.lang.String data) { 1582 return getPersistence().countByT_C_D(tableId, columnId, data); 1583 } 1584 1585 /** 1586 * Caches the expando value in the entity cache if it is enabled. 1587 * 1588 * @param expandoValue the expando value 1589 */ 1590 public static void cacheResult(ExpandoValue expandoValue) { 1591 getPersistence().cacheResult(expandoValue); 1592 } 1593 1594 /** 1595 * Caches the expando values in the entity cache if it is enabled. 1596 * 1597 * @param expandoValues the expando values 1598 */ 1599 public static void cacheResult(List<ExpandoValue> expandoValues) { 1600 getPersistence().cacheResult(expandoValues); 1601 } 1602 1603 /** 1604 * Creates a new expando value with the primary key. Does not add the expando value to the database. 1605 * 1606 * @param valueId the primary key for the new expando value 1607 * @return the new expando value 1608 */ 1609 public static ExpandoValue create(long valueId) { 1610 return getPersistence().create(valueId); 1611 } 1612 1613 /** 1614 * Removes the expando value with the primary key from the database. Also notifies the appropriate model listeners. 1615 * 1616 * @param valueId the primary key of the expando value 1617 * @return the expando value that was removed 1618 * @throws NoSuchValueException if a expando value with the primary key could not be found 1619 */ 1620 public static ExpandoValue remove(long valueId) 1621 throws com.liferay.portlet.expando.exception.NoSuchValueException { 1622 return getPersistence().remove(valueId); 1623 } 1624 1625 public static ExpandoValue updateImpl(ExpandoValue expandoValue) { 1626 return getPersistence().updateImpl(expandoValue); 1627 } 1628 1629 /** 1630 * Returns the expando value with the primary key or throws a {@link NoSuchValueException} if it could not be found. 1631 * 1632 * @param valueId the primary key of the expando value 1633 * @return the expando value 1634 * @throws NoSuchValueException if a expando value with the primary key could not be found 1635 */ 1636 public static ExpandoValue findByPrimaryKey(long valueId) 1637 throws com.liferay.portlet.expando.exception.NoSuchValueException { 1638 return getPersistence().findByPrimaryKey(valueId); 1639 } 1640 1641 /** 1642 * Returns the expando value with the primary key or returns <code>null</code> if it could not be found. 1643 * 1644 * @param valueId the primary key of the expando value 1645 * @return the expando value, or <code>null</code> if a expando value with the primary key could not be found 1646 */ 1647 public static ExpandoValue fetchByPrimaryKey(long valueId) { 1648 return getPersistence().fetchByPrimaryKey(valueId); 1649 } 1650 1651 public static java.util.Map<java.io.Serializable, ExpandoValue> fetchByPrimaryKeys( 1652 java.util.Set<java.io.Serializable> primaryKeys) { 1653 return getPersistence().fetchByPrimaryKeys(primaryKeys); 1654 } 1655 1656 /** 1657 * Returns all the expando values. 1658 * 1659 * @return the expando values 1660 */ 1661 public static List<ExpandoValue> findAll() { 1662 return getPersistence().findAll(); 1663 } 1664 1665 /** 1666 * Returns a range of all the expando values. 1667 * 1668 * <p> 1669 * 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. 1670 * </p> 1671 * 1672 * @param start the lower bound of the range of expando values 1673 * @param end the upper bound of the range of expando values (not inclusive) 1674 * @return the range of expando values 1675 */ 1676 public static List<ExpandoValue> findAll(int start, int end) { 1677 return getPersistence().findAll(start, end); 1678 } 1679 1680 /** 1681 * Returns an ordered range of all the expando values. 1682 * 1683 * <p> 1684 * 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. 1685 * </p> 1686 * 1687 * @param start the lower bound of the range of expando values 1688 * @param end the upper bound of the range of expando values (not inclusive) 1689 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1690 * @return the ordered range of expando values 1691 */ 1692 public static List<ExpandoValue> findAll(int start, int end, 1693 OrderByComparator<ExpandoValue> orderByComparator) { 1694 return getPersistence().findAll(start, end, orderByComparator); 1695 } 1696 1697 /** 1698 * Returns an ordered range of all the expando values. 1699 * 1700 * <p> 1701 * 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. 1702 * </p> 1703 * 1704 * @param start the lower bound of the range of expando values 1705 * @param end the upper bound of the range of expando values (not inclusive) 1706 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1707 * @param retrieveFromCache whether to retrieve from the finder cache 1708 * @return the ordered range of expando values 1709 */ 1710 public static List<ExpandoValue> findAll(int start, int end, 1711 OrderByComparator<ExpandoValue> orderByComparator, 1712 boolean retrieveFromCache) { 1713 return getPersistence() 1714 .findAll(start, end, orderByComparator, retrieveFromCache); 1715 } 1716 1717 /** 1718 * Removes all the expando values from the database. 1719 */ 1720 public static void removeAll() { 1721 getPersistence().removeAll(); 1722 } 1723 1724 /** 1725 * Returns the number of expando values. 1726 * 1727 * @return the number of expando values 1728 */ 1729 public static int countAll() { 1730 return getPersistence().countAll(); 1731 } 1732 1733 public static java.util.Set<java.lang.String> getBadColumnNames() { 1734 return getPersistence().getBadColumnNames(); 1735 } 1736 1737 public static ExpandoValuePersistence getPersistence() { 1738 if (_persistence == null) { 1739 _persistence = (ExpandoValuePersistence)PortalBeanLocatorUtil.locate(ExpandoValuePersistence.class.getName()); 1740 1741 ReferenceRegistry.registerReference(ExpandoValueUtil.class, 1742 "_persistence"); 1743 } 1744 1745 return _persistence; 1746 } 1747 1748 private static ExpandoValuePersistence _persistence; 1749 }