001 /** 002 * Copyright (c) 2000-present Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portlet.expando.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.service.persistence.BasePersistence; 020 021 import com.liferay.portlet.expando.exception.NoSuchColumnException; 022 import com.liferay.portlet.expando.model.ExpandoColumn; 023 024 /** 025 * The persistence interface for the expando column service. 026 * 027 * <p> 028 * Caching information and settings can be found in <code>portal.properties</code> 029 * </p> 030 * 031 * @author Brian Wing Shun Chan 032 * @see com.liferay.portlet.expando.service.persistence.impl.ExpandoColumnPersistenceImpl 033 * @see ExpandoColumnUtil 034 * @generated 035 */ 036 @ProviderType 037 public interface ExpandoColumnPersistence extends BasePersistence<ExpandoColumn> { 038 /* 039 * NOTE FOR DEVELOPERS: 040 * 041 * Never modify or reference this interface directly. Always use {@link ExpandoColumnUtil} to access the expando column persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 042 */ 043 044 /** 045 * Returns all the expando columns where tableId = ?. 046 * 047 * @param tableId the table ID 048 * @return the matching expando columns 049 */ 050 public java.util.List<ExpandoColumn> findByTableId(long tableId); 051 052 /** 053 * Returns a range of all the expando columns where tableId = ?. 054 * 055 * <p> 056 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ExpandoColumnModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 057 * </p> 058 * 059 * @param tableId the table ID 060 * @param start the lower bound of the range of expando columns 061 * @param end the upper bound of the range of expando columns (not inclusive) 062 * @return the range of matching expando columns 063 */ 064 public java.util.List<ExpandoColumn> findByTableId(long tableId, int start, 065 int end); 066 067 /** 068 * Returns an ordered range of all the expando columns where tableId = ?. 069 * 070 * <p> 071 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ExpandoColumnModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 072 * </p> 073 * 074 * @param tableId the table ID 075 * @param start the lower bound of the range of expando columns 076 * @param end the upper bound of the range of expando columns (not inclusive) 077 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 078 * @return the ordered range of matching expando columns 079 */ 080 public java.util.List<ExpandoColumn> findByTableId(long tableId, int start, 081 int end, 082 com.liferay.portal.kernel.util.OrderByComparator<ExpandoColumn> orderByComparator); 083 084 /** 085 * Returns an ordered range of all the expando columns where tableId = ?. 086 * 087 * <p> 088 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ExpandoColumnModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 089 * </p> 090 * 091 * @param tableId the table ID 092 * @param start the lower bound of the range of expando columns 093 * @param end the upper bound of the range of expando columns (not inclusive) 094 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 095 * @param retrieveFromCache whether to retrieve from the finder cache 096 * @return the ordered range of matching expando columns 097 */ 098 public java.util.List<ExpandoColumn> findByTableId(long tableId, int start, 099 int end, 100 com.liferay.portal.kernel.util.OrderByComparator<ExpandoColumn> orderByComparator, 101 boolean retrieveFromCache); 102 103 /** 104 * Returns the first expando column in the ordered set where tableId = ?. 105 * 106 * @param tableId the table ID 107 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 108 * @return the first matching expando column 109 * @throws NoSuchColumnException if a matching expando column could not be found 110 */ 111 public ExpandoColumn findByTableId_First(long tableId, 112 com.liferay.portal.kernel.util.OrderByComparator<ExpandoColumn> orderByComparator) 113 throws NoSuchColumnException; 114 115 /** 116 * Returns the first expando column in the ordered set where tableId = ?. 117 * 118 * @param tableId the table ID 119 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 120 * @return the first matching expando column, or <code>null</code> if a matching expando column could not be found 121 */ 122 public ExpandoColumn fetchByTableId_First(long tableId, 123 com.liferay.portal.kernel.util.OrderByComparator<ExpandoColumn> orderByComparator); 124 125 /** 126 * Returns the last expando column in the ordered set where tableId = ?. 127 * 128 * @param tableId the table ID 129 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 130 * @return the last matching expando column 131 * @throws NoSuchColumnException if a matching expando column could not be found 132 */ 133 public ExpandoColumn findByTableId_Last(long tableId, 134 com.liferay.portal.kernel.util.OrderByComparator<ExpandoColumn> orderByComparator) 135 throws NoSuchColumnException; 136 137 /** 138 * Returns the last expando column in the ordered set where tableId = ?. 139 * 140 * @param tableId the table ID 141 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 142 * @return the last matching expando column, or <code>null</code> if a matching expando column could not be found 143 */ 144 public ExpandoColumn fetchByTableId_Last(long tableId, 145 com.liferay.portal.kernel.util.OrderByComparator<ExpandoColumn> orderByComparator); 146 147 /** 148 * Returns the expando columns before and after the current expando column in the ordered set where tableId = ?. 149 * 150 * @param columnId the primary key of the current expando column 151 * @param tableId the table ID 152 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 153 * @return the previous, current, and next expando column 154 * @throws NoSuchColumnException if a expando column with the primary key could not be found 155 */ 156 public ExpandoColumn[] findByTableId_PrevAndNext(long columnId, 157 long tableId, 158 com.liferay.portal.kernel.util.OrderByComparator<ExpandoColumn> orderByComparator) 159 throws NoSuchColumnException; 160 161 /** 162 * Returns all the expando columns that the user has permission to view where tableId = ?. 163 * 164 * @param tableId the table ID 165 * @return the matching expando columns that the user has permission to view 166 */ 167 public java.util.List<ExpandoColumn> filterFindByTableId(long tableId); 168 169 /** 170 * Returns a range of all the expando columns that the user has permission to view where tableId = ?. 171 * 172 * <p> 173 * 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 ExpandoColumnModelImpl}. 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. 174 * </p> 175 * 176 * @param tableId the table ID 177 * @param start the lower bound of the range of expando columns 178 * @param end the upper bound of the range of expando columns (not inclusive) 179 * @return the range of matching expando columns that the user has permission to view 180 */ 181 public java.util.List<ExpandoColumn> filterFindByTableId(long tableId, 182 int start, int end); 183 184 /** 185 * Returns an ordered range of all the expando columns that the user has permissions to view where tableId = ?. 186 * 187 * <p> 188 * 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 ExpandoColumnModelImpl}. 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. 189 * </p> 190 * 191 * @param tableId the table ID 192 * @param start the lower bound of the range of expando columns 193 * @param end the upper bound of the range of expando columns (not inclusive) 194 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 195 * @return the ordered range of matching expando columns that the user has permission to view 196 */ 197 public java.util.List<ExpandoColumn> filterFindByTableId(long tableId, 198 int start, int end, 199 com.liferay.portal.kernel.util.OrderByComparator<ExpandoColumn> orderByComparator); 200 201 /** 202 * Returns the expando columns before and after the current expando column in the ordered set of expando columns that the user has permission to view where tableId = ?. 203 * 204 * @param columnId the primary key of the current expando column 205 * @param tableId the table ID 206 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 207 * @return the previous, current, and next expando column 208 * @throws NoSuchColumnException if a expando column with the primary key could not be found 209 */ 210 public ExpandoColumn[] filterFindByTableId_PrevAndNext(long columnId, 211 long tableId, 212 com.liferay.portal.kernel.util.OrderByComparator<ExpandoColumn> orderByComparator) 213 throws NoSuchColumnException; 214 215 /** 216 * Removes all the expando columns where tableId = ? from the database. 217 * 218 * @param tableId the table ID 219 */ 220 public void removeByTableId(long tableId); 221 222 /** 223 * Returns the number of expando columns where tableId = ?. 224 * 225 * @param tableId the table ID 226 * @return the number of matching expando columns 227 */ 228 public int countByTableId(long tableId); 229 230 /** 231 * Returns the number of expando columns that the user has permission to view where tableId = ?. 232 * 233 * @param tableId the table ID 234 * @return the number of matching expando columns that the user has permission to view 235 */ 236 public int filterCountByTableId(long tableId); 237 238 /** 239 * Returns all the expando columns where tableId = ? and name = any ?. 240 * 241 * <p> 242 * 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 ExpandoColumnModelImpl}. 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. 243 * </p> 244 * 245 * @param tableId the table ID 246 * @param names the names 247 * @return the matching expando columns 248 */ 249 public java.util.List<ExpandoColumn> findByT_N(long tableId, 250 java.lang.String[] names); 251 252 /** 253 * Returns a range of all the expando columns where tableId = ? and name = any ?. 254 * 255 * <p> 256 * 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 ExpandoColumnModelImpl}. 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. 257 * </p> 258 * 259 * @param tableId the table ID 260 * @param names the names 261 * @param start the lower bound of the range of expando columns 262 * @param end the upper bound of the range of expando columns (not inclusive) 263 * @return the range of matching expando columns 264 */ 265 public java.util.List<ExpandoColumn> findByT_N(long tableId, 266 java.lang.String[] names, int start, int end); 267 268 /** 269 * Returns an ordered range of all the expando columns where tableId = ? and name = any ?. 270 * 271 * <p> 272 * 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 ExpandoColumnModelImpl}. 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. 273 * </p> 274 * 275 * @param tableId the table ID 276 * @param names the names 277 * @param start the lower bound of the range of expando columns 278 * @param end the upper bound of the range of expando columns (not inclusive) 279 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 280 * @return the ordered range of matching expando columns 281 */ 282 public java.util.List<ExpandoColumn> findByT_N(long tableId, 283 java.lang.String[] names, int start, int end, 284 com.liferay.portal.kernel.util.OrderByComparator<ExpandoColumn> orderByComparator); 285 286 /** 287 * Returns an ordered range of all the expando columns where tableId = ? and name = ?, optionally using the finder cache. 288 * 289 * <p> 290 * 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 ExpandoColumnModelImpl}. 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. 291 * </p> 292 * 293 * @param tableId the table ID 294 * @param name the name 295 * @param start the lower bound of the range of expando columns 296 * @param end the upper bound of the range of expando columns (not inclusive) 297 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 298 * @param retrieveFromCache whether to retrieve from the finder cache 299 * @return the ordered range of matching expando columns 300 */ 301 public java.util.List<ExpandoColumn> findByT_N(long tableId, 302 java.lang.String[] names, int start, int end, 303 com.liferay.portal.kernel.util.OrderByComparator<ExpandoColumn> orderByComparator, 304 boolean retrieveFromCache); 305 306 /** 307 * Returns the expando column where tableId = ? and name = ? or throws a {@link NoSuchColumnException} if it could not be found. 308 * 309 * @param tableId the table ID 310 * @param name the name 311 * @return the matching expando column 312 * @throws NoSuchColumnException if a matching expando column could not be found 313 */ 314 public ExpandoColumn findByT_N(long tableId, java.lang.String name) 315 throws NoSuchColumnException; 316 317 /** 318 * Returns the expando column where tableId = ? and name = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 319 * 320 * @param tableId the table ID 321 * @param name the name 322 * @return the matching expando column, or <code>null</code> if a matching expando column could not be found 323 */ 324 public ExpandoColumn fetchByT_N(long tableId, java.lang.String name); 325 326 /** 327 * Returns the expando column where tableId = ? and name = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 328 * 329 * @param tableId the table ID 330 * @param name the name 331 * @param retrieveFromCache whether to retrieve from the finder cache 332 * @return the matching expando column, or <code>null</code> if a matching expando column could not be found 333 */ 334 public ExpandoColumn fetchByT_N(long tableId, java.lang.String name, 335 boolean retrieveFromCache); 336 337 /** 338 * Removes the expando column where tableId = ? and name = ? from the database. 339 * 340 * @param tableId the table ID 341 * @param name the name 342 * @return the expando column that was removed 343 */ 344 public ExpandoColumn removeByT_N(long tableId, java.lang.String name) 345 throws NoSuchColumnException; 346 347 /** 348 * Returns the number of expando columns where tableId = ? and name = ?. 349 * 350 * @param tableId the table ID 351 * @param name the name 352 * @return the number of matching expando columns 353 */ 354 public int countByT_N(long tableId, java.lang.String name); 355 356 /** 357 * Returns the number of expando columns where tableId = ? and name = any ?. 358 * 359 * @param tableId the table ID 360 * @param names the names 361 * @return the number of matching expando columns 362 */ 363 public int countByT_N(long tableId, java.lang.String[] names); 364 365 /** 366 * Returns the number of expando columns that the user has permission to view where tableId = ? and name = ?. 367 * 368 * @param tableId the table ID 369 * @param name the name 370 * @return the number of matching expando columns that the user has permission to view 371 */ 372 public int filterCountByT_N(long tableId, java.lang.String name); 373 374 /** 375 * Returns the number of expando columns that the user has permission to view where tableId = ? and name = any ?. 376 * 377 * @param tableId the table ID 378 * @param names the names 379 * @return the number of matching expando columns that the user has permission to view 380 */ 381 public int filterCountByT_N(long tableId, java.lang.String[] names); 382 383 /** 384 * Caches the expando column in the entity cache if it is enabled. 385 * 386 * @param expandoColumn the expando column 387 */ 388 public void cacheResult(ExpandoColumn expandoColumn); 389 390 /** 391 * Caches the expando columns in the entity cache if it is enabled. 392 * 393 * @param expandoColumns the expando columns 394 */ 395 public void cacheResult(java.util.List<ExpandoColumn> expandoColumns); 396 397 /** 398 * Creates a new expando column with the primary key. Does not add the expando column to the database. 399 * 400 * @param columnId the primary key for the new expando column 401 * @return the new expando column 402 */ 403 public ExpandoColumn create(long columnId); 404 405 /** 406 * Removes the expando column with the primary key from the database. Also notifies the appropriate model listeners. 407 * 408 * @param columnId the primary key of the expando column 409 * @return the expando column that was removed 410 * @throws NoSuchColumnException if a expando column with the primary key could not be found 411 */ 412 public ExpandoColumn remove(long columnId) throws NoSuchColumnException; 413 414 public ExpandoColumn updateImpl(ExpandoColumn expandoColumn); 415 416 /** 417 * Returns the expando column with the primary key or throws a {@link NoSuchColumnException} if it could not be found. 418 * 419 * @param columnId the primary key of the expando column 420 * @return the expando column 421 * @throws NoSuchColumnException if a expando column with the primary key could not be found 422 */ 423 public ExpandoColumn findByPrimaryKey(long columnId) 424 throws NoSuchColumnException; 425 426 /** 427 * Returns the expando column with the primary key or returns <code>null</code> if it could not be found. 428 * 429 * @param columnId the primary key of the expando column 430 * @return the expando column, or <code>null</code> if a expando column with the primary key could not be found 431 */ 432 public ExpandoColumn fetchByPrimaryKey(long columnId); 433 434 @Override 435 public java.util.Map<java.io.Serializable, ExpandoColumn> fetchByPrimaryKeys( 436 java.util.Set<java.io.Serializable> primaryKeys); 437 438 /** 439 * Returns all the expando columns. 440 * 441 * @return the expando columns 442 */ 443 public java.util.List<ExpandoColumn> findAll(); 444 445 /** 446 * Returns a range of all the expando columns. 447 * 448 * <p> 449 * 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 ExpandoColumnModelImpl}. 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. 450 * </p> 451 * 452 * @param start the lower bound of the range of expando columns 453 * @param end the upper bound of the range of expando columns (not inclusive) 454 * @return the range of expando columns 455 */ 456 public java.util.List<ExpandoColumn> findAll(int start, int end); 457 458 /** 459 * Returns an ordered range of all the expando columns. 460 * 461 * <p> 462 * 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 ExpandoColumnModelImpl}. 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. 463 * </p> 464 * 465 * @param start the lower bound of the range of expando columns 466 * @param end the upper bound of the range of expando columns (not inclusive) 467 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 468 * @return the ordered range of expando columns 469 */ 470 public java.util.List<ExpandoColumn> findAll(int start, int end, 471 com.liferay.portal.kernel.util.OrderByComparator<ExpandoColumn> orderByComparator); 472 473 /** 474 * Returns an ordered range of all the expando columns. 475 * 476 * <p> 477 * 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 ExpandoColumnModelImpl}. 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. 478 * </p> 479 * 480 * @param start the lower bound of the range of expando columns 481 * @param end the upper bound of the range of expando columns (not inclusive) 482 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 483 * @param retrieveFromCache whether to retrieve from the finder cache 484 * @return the ordered range of expando columns 485 */ 486 public java.util.List<ExpandoColumn> findAll(int start, int end, 487 com.liferay.portal.kernel.util.OrderByComparator<ExpandoColumn> orderByComparator, 488 boolean retrieveFromCache); 489 490 /** 491 * Removes all the expando columns from the database. 492 */ 493 public void removeAll(); 494 495 /** 496 * Returns the number of expando columns. 497 * 498 * @return the number of expando columns 499 */ 500 public int countAll(); 501 502 @Override 503 public java.util.Set<java.lang.String> getBadColumnNames(); 504 }