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