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.ExpandoColumn; 026 027 import java.util.List; 028 029 /** 030 * The persistence utility for the expando column service. This utility wraps {@link com.liferay.portlet.expando.service.persistence.impl.ExpandoColumnPersistenceImpl} 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 ExpandoColumnPersistence 038 * @see com.liferay.portlet.expando.service.persistence.impl.ExpandoColumnPersistenceImpl 039 * @generated 040 */ 041 @ProviderType 042 public class ExpandoColumnUtil { 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(ExpandoColumn expandoColumn) { 060 getPersistence().clearCache(expandoColumn); 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<ExpandoColumn> 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<ExpandoColumn> 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<ExpandoColumn> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator<ExpandoColumn> 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 ExpandoColumn update(ExpandoColumn expandoColumn) { 101 return getPersistence().update(expandoColumn); 102 } 103 104 /** 105 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 106 */ 107 public static ExpandoColumn update(ExpandoColumn expandoColumn, 108 ServiceContext serviceContext) { 109 return getPersistence().update(expandoColumn, serviceContext); 110 } 111 112 /** 113 * Returns all the expando columns where tableId = ?. 114 * 115 * @param tableId the table ID 116 * @return the matching expando columns 117 */ 118 public static List<ExpandoColumn> findByTableId(long tableId) { 119 return getPersistence().findByTableId(tableId); 120 } 121 122 /** 123 * Returns a range of all the expando columns 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 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. 127 * </p> 128 * 129 * @param tableId the table ID 130 * @param start the lower bound of the range of expando columns 131 * @param end the upper bound of the range of expando columns (not inclusive) 132 * @return the range of matching expando columns 133 */ 134 public static List<ExpandoColumn> 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 columns 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 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. 144 * </p> 145 * 146 * @param tableId the table ID 147 * @param start the lower bound of the range of expando columns 148 * @param end the upper bound of the range of expando columns (not inclusive) 149 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 150 * @return the ordered range of matching expando columns 151 */ 152 public static List<ExpandoColumn> findByTableId(long tableId, int start, 153 int end, OrderByComparator<ExpandoColumn> orderByComparator) { 154 return getPersistence() 155 .findByTableId(tableId, start, end, orderByComparator); 156 } 157 158 /** 159 * Returns an ordered range of all the expando columns 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 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. 163 * </p> 164 * 165 * @param tableId the table ID 166 * @param start the lower bound of the range of expando columns 167 * @param end the upper bound of the range of expando columns (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 columns 171 */ 172 public static List<ExpandoColumn> findByTableId(long tableId, int start, 173 int end, OrderByComparator<ExpandoColumn> orderByComparator, 174 boolean retrieveFromCache) { 175 return getPersistence() 176 .findByTableId(tableId, start, end, orderByComparator, 177 retrieveFromCache); 178 } 179 180 /** 181 * Returns the first expando column 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 column 186 * @throws NoSuchColumnException if a matching expando column could not be found 187 */ 188 public static ExpandoColumn findByTableId_First(long tableId, 189 OrderByComparator<ExpandoColumn> orderByComparator) 190 throws com.liferay.portlet.expando.exception.NoSuchColumnException { 191 return getPersistence().findByTableId_First(tableId, orderByComparator); 192 } 193 194 /** 195 * Returns the first expando column 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 column, or <code>null</code> if a matching expando column could not be found 200 */ 201 public static ExpandoColumn fetchByTableId_First(long tableId, 202 OrderByComparator<ExpandoColumn> orderByComparator) { 203 return getPersistence().fetchByTableId_First(tableId, orderByComparator); 204 } 205 206 /** 207 * Returns the last expando column 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 column 212 * @throws NoSuchColumnException if a matching expando column could not be found 213 */ 214 public static ExpandoColumn findByTableId_Last(long tableId, 215 OrderByComparator<ExpandoColumn> orderByComparator) 216 throws com.liferay.portlet.expando.exception.NoSuchColumnException { 217 return getPersistence().findByTableId_Last(tableId, orderByComparator); 218 } 219 220 /** 221 * Returns the last expando column 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 column, or <code>null</code> if a matching expando column could not be found 226 */ 227 public static ExpandoColumn fetchByTableId_Last(long tableId, 228 OrderByComparator<ExpandoColumn> orderByComparator) { 229 return getPersistence().fetchByTableId_Last(tableId, orderByComparator); 230 } 231 232 /** 233 * Returns the expando columns before and after the current expando column in the ordered set where tableId = ?. 234 * 235 * @param columnId the primary key of the current expando column 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 column 239 * @throws NoSuchColumnException if a expando column with the primary key could not be found 240 */ 241 public static ExpandoColumn[] findByTableId_PrevAndNext(long columnId, 242 long tableId, OrderByComparator<ExpandoColumn> orderByComparator) 243 throws com.liferay.portlet.expando.exception.NoSuchColumnException { 244 return getPersistence() 245 .findByTableId_PrevAndNext(columnId, tableId, 246 orderByComparator); 247 } 248 249 /** 250 * Returns all the expando columns that the user has permission to view where tableId = ?. 251 * 252 * @param tableId the table ID 253 * @return the matching expando columns that the user has permission to view 254 */ 255 public static List<ExpandoColumn> filterFindByTableId(long tableId) { 256 return getPersistence().filterFindByTableId(tableId); 257 } 258 259 /** 260 * Returns a range of all the expando columns that the user has permission to view where tableId = ?. 261 * 262 * <p> 263 * 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. 264 * </p> 265 * 266 * @param tableId the table ID 267 * @param start the lower bound of the range of expando columns 268 * @param end the upper bound of the range of expando columns (not inclusive) 269 * @return the range of matching expando columns that the user has permission to view 270 */ 271 public static List<ExpandoColumn> filterFindByTableId(long tableId, 272 int start, int end) { 273 return getPersistence().filterFindByTableId(tableId, start, end); 274 } 275 276 /** 277 * Returns an ordered range of all the expando columns that the user has permissions to view where tableId = ?. 278 * 279 * <p> 280 * 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. 281 * </p> 282 * 283 * @param tableId the table ID 284 * @param start the lower bound of the range of expando columns 285 * @param end the upper bound of the range of expando columns (not inclusive) 286 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 287 * @return the ordered range of matching expando columns that the user has permission to view 288 */ 289 public static List<ExpandoColumn> filterFindByTableId(long tableId, 290 int start, int end, OrderByComparator<ExpandoColumn> orderByComparator) { 291 return getPersistence() 292 .filterFindByTableId(tableId, start, end, orderByComparator); 293 } 294 295 /** 296 * 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 = ?. 297 * 298 * @param columnId the primary key of the current expando column 299 * @param tableId the table ID 300 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 301 * @return the previous, current, and next expando column 302 * @throws NoSuchColumnException if a expando column with the primary key could not be found 303 */ 304 public static ExpandoColumn[] filterFindByTableId_PrevAndNext( 305 long columnId, long tableId, 306 OrderByComparator<ExpandoColumn> orderByComparator) 307 throws com.liferay.portlet.expando.exception.NoSuchColumnException { 308 return getPersistence() 309 .filterFindByTableId_PrevAndNext(columnId, tableId, 310 orderByComparator); 311 } 312 313 /** 314 * Removes all the expando columns where tableId = ? from the database. 315 * 316 * @param tableId the table ID 317 */ 318 public static void removeByTableId(long tableId) { 319 getPersistence().removeByTableId(tableId); 320 } 321 322 /** 323 * Returns the number of expando columns where tableId = ?. 324 * 325 * @param tableId the table ID 326 * @return the number of matching expando columns 327 */ 328 public static int countByTableId(long tableId) { 329 return getPersistence().countByTableId(tableId); 330 } 331 332 /** 333 * Returns the number of expando columns that the user has permission to view where tableId = ?. 334 * 335 * @param tableId the table ID 336 * @return the number of matching expando columns that the user has permission to view 337 */ 338 public static int filterCountByTableId(long tableId) { 339 return getPersistence().filterCountByTableId(tableId); 340 } 341 342 /** 343 * Returns all the expando columns where tableId = ? and name = any ?. 344 * 345 * <p> 346 * 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. 347 * </p> 348 * 349 * @param tableId the table ID 350 * @param names the names 351 * @return the matching expando columns 352 */ 353 public static List<ExpandoColumn> findByT_N(long tableId, 354 java.lang.String[] names) { 355 return getPersistence().findByT_N(tableId, names); 356 } 357 358 /** 359 * Returns a range of all the expando columns where tableId = ? and name = any ?. 360 * 361 * <p> 362 * 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. 363 * </p> 364 * 365 * @param tableId the table ID 366 * @param names the names 367 * @param start the lower bound of the range of expando columns 368 * @param end the upper bound of the range of expando columns (not inclusive) 369 * @return the range of matching expando columns 370 */ 371 public static List<ExpandoColumn> findByT_N(long tableId, 372 java.lang.String[] names, int start, int end) { 373 return getPersistence().findByT_N(tableId, names, start, end); 374 } 375 376 /** 377 * Returns an ordered range of all the expando columns where tableId = ? and name = any ?. 378 * 379 * <p> 380 * 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. 381 * </p> 382 * 383 * @param tableId the table ID 384 * @param names the names 385 * @param start the lower bound of the range of expando columns 386 * @param end the upper bound of the range of expando columns (not inclusive) 387 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 388 * @return the ordered range of matching expando columns 389 */ 390 public static List<ExpandoColumn> findByT_N(long tableId, 391 java.lang.String[] names, int start, int end, 392 OrderByComparator<ExpandoColumn> orderByComparator) { 393 return getPersistence() 394 .findByT_N(tableId, names, start, end, orderByComparator); 395 } 396 397 /** 398 * Returns an ordered range of all the expando columns where tableId = ? and name = ?, optionally using the finder cache. 399 * 400 * <p> 401 * 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. 402 * </p> 403 * 404 * @param tableId the table ID 405 * @param name the name 406 * @param start the lower bound of the range of expando columns 407 * @param end the upper bound of the range of expando columns (not inclusive) 408 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 409 * @param retrieveFromCache whether to retrieve from the finder cache 410 * @return the ordered range of matching expando columns 411 */ 412 public static List<ExpandoColumn> findByT_N(long tableId, 413 java.lang.String[] names, int start, int end, 414 OrderByComparator<ExpandoColumn> orderByComparator, 415 boolean retrieveFromCache) { 416 return getPersistence() 417 .findByT_N(tableId, names, start, end, orderByComparator, 418 retrieveFromCache); 419 } 420 421 /** 422 * Returns the expando column where tableId = ? and name = ? or throws a {@link NoSuchColumnException} if it could not be found. 423 * 424 * @param tableId the table ID 425 * @param name the name 426 * @return the matching expando column 427 * @throws NoSuchColumnException if a matching expando column could not be found 428 */ 429 public static ExpandoColumn findByT_N(long tableId, java.lang.String name) 430 throws com.liferay.portlet.expando.exception.NoSuchColumnException { 431 return getPersistence().findByT_N(tableId, name); 432 } 433 434 /** 435 * Returns the expando column where tableId = ? and name = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 436 * 437 * @param tableId the table ID 438 * @param name the name 439 * @return the matching expando column, or <code>null</code> if a matching expando column could not be found 440 */ 441 public static ExpandoColumn fetchByT_N(long tableId, java.lang.String name) { 442 return getPersistence().fetchByT_N(tableId, name); 443 } 444 445 /** 446 * Returns the expando column where tableId = ? and name = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 447 * 448 * @param tableId the table ID 449 * @param name the name 450 * @param retrieveFromCache whether to retrieve from the finder cache 451 * @return the matching expando column, or <code>null</code> if a matching expando column could not be found 452 */ 453 public static ExpandoColumn fetchByT_N(long tableId, java.lang.String name, 454 boolean retrieveFromCache) { 455 return getPersistence().fetchByT_N(tableId, name, retrieveFromCache); 456 } 457 458 /** 459 * Removes the expando column where tableId = ? and name = ? from the database. 460 * 461 * @param tableId the table ID 462 * @param name the name 463 * @return the expando column that was removed 464 */ 465 public static ExpandoColumn removeByT_N(long tableId, java.lang.String name) 466 throws com.liferay.portlet.expando.exception.NoSuchColumnException { 467 return getPersistence().removeByT_N(tableId, name); 468 } 469 470 /** 471 * Returns the number of expando columns where tableId = ? and name = ?. 472 * 473 * @param tableId the table ID 474 * @param name the name 475 * @return the number of matching expando columns 476 */ 477 public static int countByT_N(long tableId, java.lang.String name) { 478 return getPersistence().countByT_N(tableId, name); 479 } 480 481 /** 482 * Returns the number of expando columns where tableId = ? and name = any ?. 483 * 484 * @param tableId the table ID 485 * @param names the names 486 * @return the number of matching expando columns 487 */ 488 public static int countByT_N(long tableId, java.lang.String[] names) { 489 return getPersistence().countByT_N(tableId, names); 490 } 491 492 /** 493 * Returns the number of expando columns that the user has permission to view where tableId = ? and name = ?. 494 * 495 * @param tableId the table ID 496 * @param name the name 497 * @return the number of matching expando columns that the user has permission to view 498 */ 499 public static int filterCountByT_N(long tableId, java.lang.String name) { 500 return getPersistence().filterCountByT_N(tableId, name); 501 } 502 503 /** 504 * Returns the number of expando columns that the user has permission to view where tableId = ? and name = any ?. 505 * 506 * @param tableId the table ID 507 * @param names the names 508 * @return the number of matching expando columns that the user has permission to view 509 */ 510 public static int filterCountByT_N(long tableId, java.lang.String[] names) { 511 return getPersistence().filterCountByT_N(tableId, names); 512 } 513 514 /** 515 * Caches the expando column in the entity cache if it is enabled. 516 * 517 * @param expandoColumn the expando column 518 */ 519 public static void cacheResult(ExpandoColumn expandoColumn) { 520 getPersistence().cacheResult(expandoColumn); 521 } 522 523 /** 524 * Caches the expando columns in the entity cache if it is enabled. 525 * 526 * @param expandoColumns the expando columns 527 */ 528 public static void cacheResult(List<ExpandoColumn> expandoColumns) { 529 getPersistence().cacheResult(expandoColumns); 530 } 531 532 /** 533 * Creates a new expando column with the primary key. Does not add the expando column to the database. 534 * 535 * @param columnId the primary key for the new expando column 536 * @return the new expando column 537 */ 538 public static ExpandoColumn create(long columnId) { 539 return getPersistence().create(columnId); 540 } 541 542 /** 543 * Removes the expando column with the primary key from the database. Also notifies the appropriate model listeners. 544 * 545 * @param columnId the primary key of the expando column 546 * @return the expando column that was removed 547 * @throws NoSuchColumnException if a expando column with the primary key could not be found 548 */ 549 public static ExpandoColumn remove(long columnId) 550 throws com.liferay.portlet.expando.exception.NoSuchColumnException { 551 return getPersistence().remove(columnId); 552 } 553 554 public static ExpandoColumn updateImpl(ExpandoColumn expandoColumn) { 555 return getPersistence().updateImpl(expandoColumn); 556 } 557 558 /** 559 * Returns the expando column with the primary key or throws a {@link NoSuchColumnException} if it could not be found. 560 * 561 * @param columnId the primary key of the expando column 562 * @return the expando column 563 * @throws NoSuchColumnException if a expando column with the primary key could not be found 564 */ 565 public static ExpandoColumn findByPrimaryKey(long columnId) 566 throws com.liferay.portlet.expando.exception.NoSuchColumnException { 567 return getPersistence().findByPrimaryKey(columnId); 568 } 569 570 /** 571 * Returns the expando column with the primary key or returns <code>null</code> if it could not be found. 572 * 573 * @param columnId the primary key of the expando column 574 * @return the expando column, or <code>null</code> if a expando column with the primary key could not be found 575 */ 576 public static ExpandoColumn fetchByPrimaryKey(long columnId) { 577 return getPersistence().fetchByPrimaryKey(columnId); 578 } 579 580 public static java.util.Map<java.io.Serializable, ExpandoColumn> fetchByPrimaryKeys( 581 java.util.Set<java.io.Serializable> primaryKeys) { 582 return getPersistence().fetchByPrimaryKeys(primaryKeys); 583 } 584 585 /** 586 * Returns all the expando columns. 587 * 588 * @return the expando columns 589 */ 590 public static List<ExpandoColumn> findAll() { 591 return getPersistence().findAll(); 592 } 593 594 /** 595 * Returns a range of all the expando columns. 596 * 597 * <p> 598 * 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. 599 * </p> 600 * 601 * @param start the lower bound of the range of expando columns 602 * @param end the upper bound of the range of expando columns (not inclusive) 603 * @return the range of expando columns 604 */ 605 public static List<ExpandoColumn> findAll(int start, int end) { 606 return getPersistence().findAll(start, end); 607 } 608 609 /** 610 * Returns an ordered range of all the expando columns. 611 * 612 * <p> 613 * 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. 614 * </p> 615 * 616 * @param start the lower bound of the range of expando columns 617 * @param end the upper bound of the range of expando columns (not inclusive) 618 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 619 * @return the ordered range of expando columns 620 */ 621 public static List<ExpandoColumn> findAll(int start, int end, 622 OrderByComparator<ExpandoColumn> orderByComparator) { 623 return getPersistence().findAll(start, end, orderByComparator); 624 } 625 626 /** 627 * Returns an ordered range of all the expando columns. 628 * 629 * <p> 630 * 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. 631 * </p> 632 * 633 * @param start the lower bound of the range of expando columns 634 * @param end the upper bound of the range of expando columns (not inclusive) 635 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 636 * @param retrieveFromCache whether to retrieve from the finder cache 637 * @return the ordered range of expando columns 638 */ 639 public static List<ExpandoColumn> findAll(int start, int end, 640 OrderByComparator<ExpandoColumn> orderByComparator, 641 boolean retrieveFromCache) { 642 return getPersistence() 643 .findAll(start, end, orderByComparator, retrieveFromCache); 644 } 645 646 /** 647 * Removes all the expando columns from the database. 648 */ 649 public static void removeAll() { 650 getPersistence().removeAll(); 651 } 652 653 /** 654 * Returns the number of expando columns. 655 * 656 * @return the number of expando columns 657 */ 658 public static int countAll() { 659 return getPersistence().countAll(); 660 } 661 662 public static java.util.Set<java.lang.String> getBadColumnNames() { 663 return getPersistence().getBadColumnNames(); 664 } 665 666 public static ExpandoColumnPersistence getPersistence() { 667 if (_persistence == null) { 668 _persistence = (ExpandoColumnPersistence)PortalBeanLocatorUtil.locate(ExpandoColumnPersistence.class.getName()); 669 670 ReferenceRegistry.registerReference(ExpandoColumnUtil.class, 671 "_persistence"); 672 } 673 674 return _persistence; 675 } 676 677 private static ExpandoColumnPersistence _persistence; 678 }