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