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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63; 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 = &#63;.
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 = &#63;.
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 = &#63; and name = any &#63;.
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 = &#63; and name = any &#63;.
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 = &#63; and name = any &#63;.
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 = &#63; and name = &#63;, 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 = &#63; and name = &#63; 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 = &#63; and name = &#63; 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 = &#63; and name = &#63; 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 = &#63; and name = &#63; 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 = &#63; and name = &#63;.
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 = &#63; and name = any &#63;.
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 = &#63; and name = &#63;.
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 = &#63; and name = any &#63;.
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    }