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 the first expando value in the ordered set where tableId = &#63;.
160            *
161            * @param tableId the table ID
162            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
163            * @return the first matching expando value
164            * @throws NoSuchValueException if a matching expando value could not be found
165            */
166            public static ExpandoValue findByTableId_First(long tableId,
167                    OrderByComparator<ExpandoValue> orderByComparator)
168                    throws com.liferay.portlet.expando.NoSuchValueException {
169                    return getPersistence().findByTableId_First(tableId, orderByComparator);
170            }
171    
172            /**
173            * Returns the first expando value in the ordered set where tableId = &#63;.
174            *
175            * @param tableId the table ID
176            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
177            * @return the first matching expando value, or <code>null</code> if a matching expando value could not be found
178            */
179            public static ExpandoValue fetchByTableId_First(long tableId,
180                    OrderByComparator<ExpandoValue> orderByComparator) {
181                    return getPersistence().fetchByTableId_First(tableId, orderByComparator);
182            }
183    
184            /**
185            * Returns the last expando value in the ordered set where tableId = &#63;.
186            *
187            * @param tableId the table ID
188            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
189            * @return the last matching expando value
190            * @throws NoSuchValueException if a matching expando value could not be found
191            */
192            public static ExpandoValue findByTableId_Last(long tableId,
193                    OrderByComparator<ExpandoValue> orderByComparator)
194                    throws com.liferay.portlet.expando.NoSuchValueException {
195                    return getPersistence().findByTableId_Last(tableId, orderByComparator);
196            }
197    
198            /**
199            * Returns the last expando value in the ordered set where tableId = &#63;.
200            *
201            * @param tableId the table ID
202            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
203            * @return the last matching expando value, or <code>null</code> if a matching expando value could not be found
204            */
205            public static ExpandoValue fetchByTableId_Last(long tableId,
206                    OrderByComparator<ExpandoValue> orderByComparator) {
207                    return getPersistence().fetchByTableId_Last(tableId, orderByComparator);
208            }
209    
210            /**
211            * Returns the expando values before and after the current expando value in the ordered set where tableId = &#63;.
212            *
213            * @param valueId the primary key of the current expando value
214            * @param tableId the table ID
215            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
216            * @return the previous, current, and next expando value
217            * @throws NoSuchValueException if a expando value with the primary key could not be found
218            */
219            public static ExpandoValue[] findByTableId_PrevAndNext(long valueId,
220                    long tableId, OrderByComparator<ExpandoValue> orderByComparator)
221                    throws com.liferay.portlet.expando.NoSuchValueException {
222                    return getPersistence()
223                                       .findByTableId_PrevAndNext(valueId, tableId,
224                            orderByComparator);
225            }
226    
227            /**
228            * Removes all the expando values where tableId = &#63; from the database.
229            *
230            * @param tableId the table ID
231            */
232            public static void removeByTableId(long tableId) {
233                    getPersistence().removeByTableId(tableId);
234            }
235    
236            /**
237            * Returns the number of expando values where tableId = &#63;.
238            *
239            * @param tableId the table ID
240            * @return the number of matching expando values
241            */
242            public static int countByTableId(long tableId) {
243                    return getPersistence().countByTableId(tableId);
244            }
245    
246            /**
247            * Returns all the expando values where columnId = &#63;.
248            *
249            * @param columnId the column ID
250            * @return the matching expando values
251            */
252            public static List<ExpandoValue> findByColumnId(long columnId) {
253                    return getPersistence().findByColumnId(columnId);
254            }
255    
256            /**
257            * Returns a range of all the expando values where columnId = &#63;.
258            *
259            * <p>
260            * 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.
261            * </p>
262            *
263            * @param columnId the column ID
264            * @param start the lower bound of the range of expando values
265            * @param end the upper bound of the range of expando values (not inclusive)
266            * @return the range of matching expando values
267            */
268            public static List<ExpandoValue> findByColumnId(long columnId, int start,
269                    int end) {
270                    return getPersistence().findByColumnId(columnId, start, end);
271            }
272    
273            /**
274            * Returns an ordered range of all the expando values where columnId = &#63;.
275            *
276            * <p>
277            * 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.
278            * </p>
279            *
280            * @param columnId the column ID
281            * @param start the lower bound of the range of expando values
282            * @param end the upper bound of the range of expando values (not inclusive)
283            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
284            * @return the ordered range of matching expando values
285            */
286            public static List<ExpandoValue> findByColumnId(long columnId, int start,
287                    int end, OrderByComparator<ExpandoValue> orderByComparator) {
288                    return getPersistence()
289                                       .findByColumnId(columnId, start, end, orderByComparator);
290            }
291    
292            /**
293            * Returns the first expando value in the ordered set where columnId = &#63;.
294            *
295            * @param columnId the column ID
296            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
297            * @return the first matching expando value
298            * @throws NoSuchValueException if a matching expando value could not be found
299            */
300            public static ExpandoValue findByColumnId_First(long columnId,
301                    OrderByComparator<ExpandoValue> orderByComparator)
302                    throws com.liferay.portlet.expando.NoSuchValueException {
303                    return getPersistence().findByColumnId_First(columnId, orderByComparator);
304            }
305    
306            /**
307            * Returns the first expando value in the ordered set where columnId = &#63;.
308            *
309            * @param columnId the column ID
310            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
311            * @return the first matching expando value, or <code>null</code> if a matching expando value could not be found
312            */
313            public static ExpandoValue fetchByColumnId_First(long columnId,
314                    OrderByComparator<ExpandoValue> orderByComparator) {
315                    return getPersistence()
316                                       .fetchByColumnId_First(columnId, orderByComparator);
317            }
318    
319            /**
320            * Returns the last expando value in the ordered set where columnId = &#63;.
321            *
322            * @param columnId the column ID
323            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
324            * @return the last matching expando value
325            * @throws NoSuchValueException if a matching expando value could not be found
326            */
327            public static ExpandoValue findByColumnId_Last(long columnId,
328                    OrderByComparator<ExpandoValue> orderByComparator)
329                    throws com.liferay.portlet.expando.NoSuchValueException {
330                    return getPersistence().findByColumnId_Last(columnId, orderByComparator);
331            }
332    
333            /**
334            * Returns the last expando value in the ordered set where columnId = &#63;.
335            *
336            * @param columnId the column ID
337            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
338            * @return the last matching expando value, or <code>null</code> if a matching expando value could not be found
339            */
340            public static ExpandoValue fetchByColumnId_Last(long columnId,
341                    OrderByComparator<ExpandoValue> orderByComparator) {
342                    return getPersistence().fetchByColumnId_Last(columnId, orderByComparator);
343            }
344    
345            /**
346            * Returns the expando values before and after the current expando value in the ordered set where columnId = &#63;.
347            *
348            * @param valueId the primary key of the current expando value
349            * @param columnId the column ID
350            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
351            * @return the previous, current, and next expando value
352            * @throws NoSuchValueException if a expando value with the primary key could not be found
353            */
354            public static ExpandoValue[] findByColumnId_PrevAndNext(long valueId,
355                    long columnId, OrderByComparator<ExpandoValue> orderByComparator)
356                    throws com.liferay.portlet.expando.NoSuchValueException {
357                    return getPersistence()
358                                       .findByColumnId_PrevAndNext(valueId, columnId,
359                            orderByComparator);
360            }
361    
362            /**
363            * Removes all the expando values where columnId = &#63; from the database.
364            *
365            * @param columnId the column ID
366            */
367            public static void removeByColumnId(long columnId) {
368                    getPersistence().removeByColumnId(columnId);
369            }
370    
371            /**
372            * Returns the number of expando values where columnId = &#63;.
373            *
374            * @param columnId the column ID
375            * @return the number of matching expando values
376            */
377            public static int countByColumnId(long columnId) {
378                    return getPersistence().countByColumnId(columnId);
379            }
380    
381            /**
382            * Returns all the expando values where rowId = &#63;.
383            *
384            * @param rowId the row ID
385            * @return the matching expando values
386            */
387            public static List<ExpandoValue> findByRowId(long rowId) {
388                    return getPersistence().findByRowId(rowId);
389            }
390    
391            /**
392            * Returns a range of all the expando values where rowId = &#63;.
393            *
394            * <p>
395            * 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.
396            * </p>
397            *
398            * @param rowId the row ID
399            * @param start the lower bound of the range of expando values
400            * @param end the upper bound of the range of expando values (not inclusive)
401            * @return the range of matching expando values
402            */
403            public static List<ExpandoValue> findByRowId(long rowId, int start, int end) {
404                    return getPersistence().findByRowId(rowId, start, end);
405            }
406    
407            /**
408            * Returns an ordered range of all the expando values where rowId = &#63;.
409            *
410            * <p>
411            * 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.
412            * </p>
413            *
414            * @param rowId the row ID
415            * @param start the lower bound of the range of expando values
416            * @param end the upper bound of the range of expando values (not inclusive)
417            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
418            * @return the ordered range of matching expando values
419            */
420            public static List<ExpandoValue> findByRowId(long rowId, int start,
421                    int end, OrderByComparator<ExpandoValue> orderByComparator) {
422                    return getPersistence().findByRowId(rowId, start, end, orderByComparator);
423            }
424    
425            /**
426            * Returns the first expando value in the ordered set where rowId = &#63;.
427            *
428            * @param rowId the row ID
429            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
430            * @return the first matching expando value
431            * @throws NoSuchValueException if a matching expando value could not be found
432            */
433            public static ExpandoValue findByRowId_First(long rowId,
434                    OrderByComparator<ExpandoValue> orderByComparator)
435                    throws com.liferay.portlet.expando.NoSuchValueException {
436                    return getPersistence().findByRowId_First(rowId, orderByComparator);
437            }
438    
439            /**
440            * Returns the first expando value in the ordered set where rowId = &#63;.
441            *
442            * @param rowId the row ID
443            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
444            * @return the first matching expando value, or <code>null</code> if a matching expando value could not be found
445            */
446            public static ExpandoValue fetchByRowId_First(long rowId,
447                    OrderByComparator<ExpandoValue> orderByComparator) {
448                    return getPersistence().fetchByRowId_First(rowId, orderByComparator);
449            }
450    
451            /**
452            * Returns the last expando value in the ordered set where rowId = &#63;.
453            *
454            * @param rowId the row ID
455            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
456            * @return the last matching expando value
457            * @throws NoSuchValueException if a matching expando value could not be found
458            */
459            public static ExpandoValue findByRowId_Last(long rowId,
460                    OrderByComparator<ExpandoValue> orderByComparator)
461                    throws com.liferay.portlet.expando.NoSuchValueException {
462                    return getPersistence().findByRowId_Last(rowId, orderByComparator);
463            }
464    
465            /**
466            * Returns the last expando value in the ordered set where rowId = &#63;.
467            *
468            * @param rowId the row ID
469            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
470            * @return the last matching expando value, or <code>null</code> if a matching expando value could not be found
471            */
472            public static ExpandoValue fetchByRowId_Last(long rowId,
473                    OrderByComparator<ExpandoValue> orderByComparator) {
474                    return getPersistence().fetchByRowId_Last(rowId, orderByComparator);
475            }
476    
477            /**
478            * Returns the expando values before and after the current expando value in the ordered set where rowId = &#63;.
479            *
480            * @param valueId the primary key of the current expando value
481            * @param rowId the row ID
482            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
483            * @return the previous, current, and next expando value
484            * @throws NoSuchValueException if a expando value with the primary key could not be found
485            */
486            public static ExpandoValue[] findByRowId_PrevAndNext(long valueId,
487                    long rowId, OrderByComparator<ExpandoValue> orderByComparator)
488                    throws com.liferay.portlet.expando.NoSuchValueException {
489                    return getPersistence()
490                                       .findByRowId_PrevAndNext(valueId, rowId, orderByComparator);
491            }
492    
493            /**
494            * Removes all the expando values where rowId = &#63; from the database.
495            *
496            * @param rowId the row ID
497            */
498            public static void removeByRowId(long rowId) {
499                    getPersistence().removeByRowId(rowId);
500            }
501    
502            /**
503            * Returns the number of expando values where rowId = &#63;.
504            *
505            * @param rowId the row ID
506            * @return the number of matching expando values
507            */
508            public static int countByRowId(long rowId) {
509                    return getPersistence().countByRowId(rowId);
510            }
511    
512            /**
513            * Returns all the expando values where tableId = &#63; and columnId = &#63;.
514            *
515            * @param tableId the table ID
516            * @param columnId the column ID
517            * @return the matching expando values
518            */
519            public static List<ExpandoValue> findByT_C(long tableId, long columnId) {
520                    return getPersistence().findByT_C(tableId, columnId);
521            }
522    
523            /**
524            * Returns a range of all the expando values where tableId = &#63; and columnId = &#63;.
525            *
526            * <p>
527            * 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.
528            * </p>
529            *
530            * @param tableId the table ID
531            * @param columnId the column ID
532            * @param start the lower bound of the range of expando values
533            * @param end the upper bound of the range of expando values (not inclusive)
534            * @return the range of matching expando values
535            */
536            public static List<ExpandoValue> findByT_C(long tableId, long columnId,
537                    int start, int end) {
538                    return getPersistence().findByT_C(tableId, columnId, start, end);
539            }
540    
541            /**
542            * Returns an ordered range of all the expando values where tableId = &#63; and columnId = &#63;.
543            *
544            * <p>
545            * 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.
546            * </p>
547            *
548            * @param tableId the table ID
549            * @param columnId the column ID
550            * @param start the lower bound of the range of expando values
551            * @param end the upper bound of the range of expando values (not inclusive)
552            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
553            * @return the ordered range of matching expando values
554            */
555            public static List<ExpandoValue> findByT_C(long tableId, long columnId,
556                    int start, int end, OrderByComparator<ExpandoValue> orderByComparator) {
557                    return getPersistence()
558                                       .findByT_C(tableId, columnId, start, end, orderByComparator);
559            }
560    
561            /**
562            * Returns the first expando value in the ordered set where tableId = &#63; and columnId = &#63;.
563            *
564            * @param tableId the table ID
565            * @param columnId the column ID
566            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
567            * @return the first matching expando value
568            * @throws NoSuchValueException if a matching expando value could not be found
569            */
570            public static ExpandoValue findByT_C_First(long tableId, long columnId,
571                    OrderByComparator<ExpandoValue> orderByComparator)
572                    throws com.liferay.portlet.expando.NoSuchValueException {
573                    return getPersistence()
574                                       .findByT_C_First(tableId, columnId, orderByComparator);
575            }
576    
577            /**
578            * Returns the first expando value in the ordered set where tableId = &#63; and columnId = &#63;.
579            *
580            * @param tableId the table ID
581            * @param columnId the column ID
582            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
583            * @return the first matching expando value, or <code>null</code> if a matching expando value could not be found
584            */
585            public static ExpandoValue fetchByT_C_First(long tableId, long columnId,
586                    OrderByComparator<ExpandoValue> orderByComparator) {
587                    return getPersistence()
588                                       .fetchByT_C_First(tableId, columnId, orderByComparator);
589            }
590    
591            /**
592            * Returns the last expando value in the ordered set where tableId = &#63; and columnId = &#63;.
593            *
594            * @param tableId the table ID
595            * @param columnId the column ID
596            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
597            * @return the last matching expando value
598            * @throws NoSuchValueException if a matching expando value could not be found
599            */
600            public static ExpandoValue findByT_C_Last(long tableId, long columnId,
601                    OrderByComparator<ExpandoValue> orderByComparator)
602                    throws com.liferay.portlet.expando.NoSuchValueException {
603                    return getPersistence()
604                                       .findByT_C_Last(tableId, columnId, orderByComparator);
605            }
606    
607            /**
608            * Returns the last expando value in the ordered set where tableId = &#63; and columnId = &#63;.
609            *
610            * @param tableId the table ID
611            * @param columnId the column ID
612            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
613            * @return the last matching expando value, or <code>null</code> if a matching expando value could not be found
614            */
615            public static ExpandoValue fetchByT_C_Last(long tableId, long columnId,
616                    OrderByComparator<ExpandoValue> orderByComparator) {
617                    return getPersistence()
618                                       .fetchByT_C_Last(tableId, columnId, orderByComparator);
619            }
620    
621            /**
622            * Returns the expando values before and after the current expando value in the ordered set where tableId = &#63; and columnId = &#63;.
623            *
624            * @param valueId the primary key of the current expando value
625            * @param tableId the table ID
626            * @param columnId the column ID
627            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
628            * @return the previous, current, and next expando value
629            * @throws NoSuchValueException if a expando value with the primary key could not be found
630            */
631            public static ExpandoValue[] findByT_C_PrevAndNext(long valueId,
632                    long tableId, long columnId,
633                    OrderByComparator<ExpandoValue> orderByComparator)
634                    throws com.liferay.portlet.expando.NoSuchValueException {
635                    return getPersistence()
636                                       .findByT_C_PrevAndNext(valueId, tableId, columnId,
637                            orderByComparator);
638            }
639    
640            /**
641            * Removes all the expando values where tableId = &#63; and columnId = &#63; from the database.
642            *
643            * @param tableId the table ID
644            * @param columnId the column ID
645            */
646            public static void removeByT_C(long tableId, long columnId) {
647                    getPersistence().removeByT_C(tableId, columnId);
648            }
649    
650            /**
651            * Returns the number of expando values where tableId = &#63; and columnId = &#63;.
652            *
653            * @param tableId the table ID
654            * @param columnId the column ID
655            * @return the number of matching expando values
656            */
657            public static int countByT_C(long tableId, long columnId) {
658                    return getPersistence().countByT_C(tableId, columnId);
659            }
660    
661            /**
662            * Returns all the expando values where tableId = &#63; and rowId = &#63;.
663            *
664            * @param tableId the table ID
665            * @param rowId the row ID
666            * @return the matching expando values
667            */
668            public static List<ExpandoValue> findByT_R(long tableId, long rowId) {
669                    return getPersistence().findByT_R(tableId, rowId);
670            }
671    
672            /**
673            * Returns a range of all the expando values where tableId = &#63; and rowId = &#63;.
674            *
675            * <p>
676            * 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.
677            * </p>
678            *
679            * @param tableId the table ID
680            * @param rowId the row ID
681            * @param start the lower bound of the range of expando values
682            * @param end the upper bound of the range of expando values (not inclusive)
683            * @return the range of matching expando values
684            */
685            public static List<ExpandoValue> findByT_R(long tableId, long rowId,
686                    int start, int end) {
687                    return getPersistence().findByT_R(tableId, rowId, start, end);
688            }
689    
690            /**
691            * Returns an ordered range of all the expando values where tableId = &#63; and rowId = &#63;.
692            *
693            * <p>
694            * 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.
695            * </p>
696            *
697            * @param tableId the table ID
698            * @param rowId the row ID
699            * @param start the lower bound of the range of expando values
700            * @param end the upper bound of the range of expando values (not inclusive)
701            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
702            * @return the ordered range of matching expando values
703            */
704            public static List<ExpandoValue> findByT_R(long tableId, long rowId,
705                    int start, int end, OrderByComparator<ExpandoValue> orderByComparator) {
706                    return getPersistence()
707                                       .findByT_R(tableId, rowId, start, end, orderByComparator);
708            }
709    
710            /**
711            * Returns the first expando value in the ordered set where tableId = &#63; and rowId = &#63;.
712            *
713            * @param tableId the table ID
714            * @param rowId the row ID
715            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
716            * @return the first matching expando value
717            * @throws NoSuchValueException if a matching expando value could not be found
718            */
719            public static ExpandoValue findByT_R_First(long tableId, long rowId,
720                    OrderByComparator<ExpandoValue> orderByComparator)
721                    throws com.liferay.portlet.expando.NoSuchValueException {
722                    return getPersistence()
723                                       .findByT_R_First(tableId, rowId, orderByComparator);
724            }
725    
726            /**
727            * Returns the first expando value in the ordered set where tableId = &#63; and rowId = &#63;.
728            *
729            * @param tableId the table ID
730            * @param rowId the row ID
731            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
732            * @return the first matching expando value, or <code>null</code> if a matching expando value could not be found
733            */
734            public static ExpandoValue fetchByT_R_First(long tableId, long rowId,
735                    OrderByComparator<ExpandoValue> orderByComparator) {
736                    return getPersistence()
737                                       .fetchByT_R_First(tableId, rowId, orderByComparator);
738            }
739    
740            /**
741            * Returns the last expando value in the ordered set where tableId = &#63; and rowId = &#63;.
742            *
743            * @param tableId the table ID
744            * @param rowId the row ID
745            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
746            * @return the last matching expando value
747            * @throws NoSuchValueException if a matching expando value could not be found
748            */
749            public static ExpandoValue findByT_R_Last(long tableId, long rowId,
750                    OrderByComparator<ExpandoValue> orderByComparator)
751                    throws com.liferay.portlet.expando.NoSuchValueException {
752                    return getPersistence().findByT_R_Last(tableId, rowId, orderByComparator);
753            }
754    
755            /**
756            * Returns the last expando value in the ordered set where tableId = &#63; and rowId = &#63;.
757            *
758            * @param tableId the table ID
759            * @param rowId the row ID
760            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
761            * @return the last matching expando value, or <code>null</code> if a matching expando value could not be found
762            */
763            public static ExpandoValue fetchByT_R_Last(long tableId, long rowId,
764                    OrderByComparator<ExpandoValue> orderByComparator) {
765                    return getPersistence()
766                                       .fetchByT_R_Last(tableId, rowId, orderByComparator);
767            }
768    
769            /**
770            * Returns the expando values before and after the current expando value in the ordered set where tableId = &#63; and rowId = &#63;.
771            *
772            * @param valueId the primary key of the current expando value
773            * @param tableId the table ID
774            * @param rowId the row ID
775            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
776            * @return the previous, current, and next expando value
777            * @throws NoSuchValueException if a expando value with the primary key could not be found
778            */
779            public static ExpandoValue[] findByT_R_PrevAndNext(long valueId,
780                    long tableId, long rowId,
781                    OrderByComparator<ExpandoValue> orderByComparator)
782                    throws com.liferay.portlet.expando.NoSuchValueException {
783                    return getPersistence()
784                                       .findByT_R_PrevAndNext(valueId, tableId, rowId,
785                            orderByComparator);
786            }
787    
788            /**
789            * Removes all the expando values where tableId = &#63; and rowId = &#63; from the database.
790            *
791            * @param tableId the table ID
792            * @param rowId the row ID
793            */
794            public static void removeByT_R(long tableId, long rowId) {
795                    getPersistence().removeByT_R(tableId, rowId);
796            }
797    
798            /**
799            * Returns the number of expando values where tableId = &#63; and rowId = &#63;.
800            *
801            * @param tableId the table ID
802            * @param rowId the row ID
803            * @return the number of matching expando values
804            */
805            public static int countByT_R(long tableId, long rowId) {
806                    return getPersistence().countByT_R(tableId, rowId);
807            }
808    
809            /**
810            * Returns all the expando values where tableId = &#63; and classPK = &#63;.
811            *
812            * @param tableId the table ID
813            * @param classPK the class p k
814            * @return the matching expando values
815            */
816            public static List<ExpandoValue> findByT_CPK(long tableId, long classPK) {
817                    return getPersistence().findByT_CPK(tableId, classPK);
818            }
819    
820            /**
821            * Returns a range of all the expando values where tableId = &#63; and classPK = &#63;.
822            *
823            * <p>
824            * 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.
825            * </p>
826            *
827            * @param tableId the table ID
828            * @param classPK the class p k
829            * @param start the lower bound of the range of expando values
830            * @param end the upper bound of the range of expando values (not inclusive)
831            * @return the range of matching expando values
832            */
833            public static List<ExpandoValue> findByT_CPK(long tableId, long classPK,
834                    int start, int end) {
835                    return getPersistence().findByT_CPK(tableId, classPK, start, end);
836            }
837    
838            /**
839            * Returns an ordered range of all the expando values where tableId = &#63; and classPK = &#63;.
840            *
841            * <p>
842            * 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.
843            * </p>
844            *
845            * @param tableId the table ID
846            * @param classPK the class p k
847            * @param start the lower bound of the range of expando values
848            * @param end the upper bound of the range of expando values (not inclusive)
849            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
850            * @return the ordered range of matching expando values
851            */
852            public static List<ExpandoValue> findByT_CPK(long tableId, long classPK,
853                    int start, int end, OrderByComparator<ExpandoValue> orderByComparator) {
854                    return getPersistence()
855                                       .findByT_CPK(tableId, classPK, start, end, orderByComparator);
856            }
857    
858            /**
859            * Returns the first expando value in the ordered set where tableId = &#63; and classPK = &#63;.
860            *
861            * @param tableId the table ID
862            * @param classPK the class p k
863            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
864            * @return the first matching expando value
865            * @throws NoSuchValueException if a matching expando value could not be found
866            */
867            public static ExpandoValue findByT_CPK_First(long tableId, long classPK,
868                    OrderByComparator<ExpandoValue> orderByComparator)
869                    throws com.liferay.portlet.expando.NoSuchValueException {
870                    return getPersistence()
871                                       .findByT_CPK_First(tableId, classPK, orderByComparator);
872            }
873    
874            /**
875            * Returns the first expando value in the ordered set where tableId = &#63; and classPK = &#63;.
876            *
877            * @param tableId the table ID
878            * @param classPK the class p k
879            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
880            * @return the first matching expando value, or <code>null</code> if a matching expando value could not be found
881            */
882            public static ExpandoValue fetchByT_CPK_First(long tableId, long classPK,
883                    OrderByComparator<ExpandoValue> orderByComparator) {
884                    return getPersistence()
885                                       .fetchByT_CPK_First(tableId, classPK, orderByComparator);
886            }
887    
888            /**
889            * Returns the last expando value in the ordered set where tableId = &#63; and classPK = &#63;.
890            *
891            * @param tableId the table ID
892            * @param classPK the class p k
893            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
894            * @return the last matching expando value
895            * @throws NoSuchValueException if a matching expando value could not be found
896            */
897            public static ExpandoValue findByT_CPK_Last(long tableId, long classPK,
898                    OrderByComparator<ExpandoValue> orderByComparator)
899                    throws com.liferay.portlet.expando.NoSuchValueException {
900                    return getPersistence()
901                                       .findByT_CPK_Last(tableId, classPK, orderByComparator);
902            }
903    
904            /**
905            * Returns the last expando value in the ordered set where tableId = &#63; and classPK = &#63;.
906            *
907            * @param tableId the table ID
908            * @param classPK the class p k
909            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
910            * @return the last matching expando value, or <code>null</code> if a matching expando value could not be found
911            */
912            public static ExpandoValue fetchByT_CPK_Last(long tableId, long classPK,
913                    OrderByComparator<ExpandoValue> orderByComparator) {
914                    return getPersistence()
915                                       .fetchByT_CPK_Last(tableId, classPK, orderByComparator);
916            }
917    
918            /**
919            * Returns the expando values before and after the current expando value in the ordered set where tableId = &#63; and classPK = &#63;.
920            *
921            * @param valueId the primary key of the current expando value
922            * @param tableId the table ID
923            * @param classPK the class p k
924            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
925            * @return the previous, current, and next expando value
926            * @throws NoSuchValueException if a expando value with the primary key could not be found
927            */
928            public static ExpandoValue[] findByT_CPK_PrevAndNext(long valueId,
929                    long tableId, long classPK,
930                    OrderByComparator<ExpandoValue> orderByComparator)
931                    throws com.liferay.portlet.expando.NoSuchValueException {
932                    return getPersistence()
933                                       .findByT_CPK_PrevAndNext(valueId, tableId, classPK,
934                            orderByComparator);
935            }
936    
937            /**
938            * Removes all the expando values where tableId = &#63; and classPK = &#63; from the database.
939            *
940            * @param tableId the table ID
941            * @param classPK the class p k
942            */
943            public static void removeByT_CPK(long tableId, long classPK) {
944                    getPersistence().removeByT_CPK(tableId, classPK);
945            }
946    
947            /**
948            * Returns the number of expando values where tableId = &#63; and classPK = &#63;.
949            *
950            * @param tableId the table ID
951            * @param classPK the class p k
952            * @return the number of matching expando values
953            */
954            public static int countByT_CPK(long tableId, long classPK) {
955                    return getPersistence().countByT_CPK(tableId, classPK);
956            }
957    
958            /**
959            * Returns the expando value where columnId = &#63; and rowId = &#63; or throws a {@link NoSuchValueException} if it could not be found.
960            *
961            * @param columnId the column ID
962            * @param rowId the row ID
963            * @return the matching expando value
964            * @throws NoSuchValueException if a matching expando value could not be found
965            */
966            public static ExpandoValue findByC_R(long columnId, long rowId)
967                    throws com.liferay.portlet.expando.NoSuchValueException {
968                    return getPersistence().findByC_R(columnId, rowId);
969            }
970    
971            /**
972            * 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.
973            *
974            * @param columnId the column ID
975            * @param rowId the row ID
976            * @return the matching expando value, or <code>null</code> if a matching expando value could not be found
977            */
978            public static ExpandoValue fetchByC_R(long columnId, long rowId) {
979                    return getPersistence().fetchByC_R(columnId, rowId);
980            }
981    
982            /**
983            * 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.
984            *
985            * @param columnId the column ID
986            * @param rowId the row ID
987            * @param retrieveFromCache whether to use the finder cache
988            * @return the matching expando value, or <code>null</code> if a matching expando value could not be found
989            */
990            public static ExpandoValue fetchByC_R(long columnId, long rowId,
991                    boolean retrieveFromCache) {
992                    return getPersistence().fetchByC_R(columnId, rowId, retrieveFromCache);
993            }
994    
995            /**
996            * Removes the expando value where columnId = &#63; and rowId = &#63; from the database.
997            *
998            * @param columnId the column ID
999            * @param rowId the row ID
1000            * @return the expando value that was removed
1001            */
1002            public static ExpandoValue removeByC_R(long columnId, long rowId)
1003                    throws com.liferay.portlet.expando.NoSuchValueException {
1004                    return getPersistence().removeByC_R(columnId, rowId);
1005            }
1006    
1007            /**
1008            * Returns the number of expando values where columnId = &#63; and rowId = &#63;.
1009            *
1010            * @param columnId the column ID
1011            * @param rowId the row ID
1012            * @return the number of matching expando values
1013            */
1014            public static int countByC_R(long columnId, long rowId) {
1015                    return getPersistence().countByC_R(columnId, rowId);
1016            }
1017    
1018            /**
1019            * Returns all the expando values where classNameId = &#63; and classPK = &#63;.
1020            *
1021            * @param classNameId the class name ID
1022            * @param classPK the class p k
1023            * @return the matching expando values
1024            */
1025            public static List<ExpandoValue> findByC_C(long classNameId, long classPK) {
1026                    return getPersistence().findByC_C(classNameId, classPK);
1027            }
1028    
1029            /**
1030            * Returns a range of all the expando values where classNameId = &#63; and classPK = &#63;.
1031            *
1032            * <p>
1033            * 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.
1034            * </p>
1035            *
1036            * @param classNameId the class name ID
1037            * @param classPK the class p k
1038            * @param start the lower bound of the range of expando values
1039            * @param end the upper bound of the range of expando values (not inclusive)
1040            * @return the range of matching expando values
1041            */
1042            public static List<ExpandoValue> findByC_C(long classNameId, long classPK,
1043                    int start, int end) {
1044                    return getPersistence().findByC_C(classNameId, classPK, start, end);
1045            }
1046    
1047            /**
1048            * Returns an ordered range of all the expando values where classNameId = &#63; and classPK = &#63;.
1049            *
1050            * <p>
1051            * 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.
1052            * </p>
1053            *
1054            * @param classNameId the class name ID
1055            * @param classPK the class p k
1056            * @param start the lower bound of the range of expando values
1057            * @param end the upper bound of the range of expando values (not inclusive)
1058            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1059            * @return the ordered range of matching expando values
1060            */
1061            public static List<ExpandoValue> findByC_C(long classNameId, long classPK,
1062                    int start, int end, OrderByComparator<ExpandoValue> orderByComparator) {
1063                    return getPersistence()
1064                                       .findByC_C(classNameId, classPK, start, end,
1065                            orderByComparator);
1066            }
1067    
1068            /**
1069            * Returns the first expando value in the ordered set where classNameId = &#63; and classPK = &#63;.
1070            *
1071            * @param classNameId the class name ID
1072            * @param classPK the class p k
1073            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1074            * @return the first matching expando value
1075            * @throws NoSuchValueException if a matching expando value could not be found
1076            */
1077            public static ExpandoValue findByC_C_First(long classNameId, long classPK,
1078                    OrderByComparator<ExpandoValue> orderByComparator)
1079                    throws com.liferay.portlet.expando.NoSuchValueException {
1080                    return getPersistence()
1081                                       .findByC_C_First(classNameId, classPK, orderByComparator);
1082            }
1083    
1084            /**
1085            * Returns the first expando value in the ordered set where classNameId = &#63; and classPK = &#63;.
1086            *
1087            * @param classNameId the class name ID
1088            * @param classPK the class p k
1089            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1090            * @return the first matching expando value, or <code>null</code> if a matching expando value could not be found
1091            */
1092            public static ExpandoValue fetchByC_C_First(long classNameId, long classPK,
1093                    OrderByComparator<ExpandoValue> orderByComparator) {
1094                    return getPersistence()
1095                                       .fetchByC_C_First(classNameId, classPK, orderByComparator);
1096            }
1097    
1098            /**
1099            * Returns the last expando value in the ordered set where classNameId = &#63; and classPK = &#63;.
1100            *
1101            * @param classNameId the class name ID
1102            * @param classPK the class p k
1103            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1104            * @return the last matching expando value
1105            * @throws NoSuchValueException if a matching expando value could not be found
1106            */
1107            public static ExpandoValue findByC_C_Last(long classNameId, long classPK,
1108                    OrderByComparator<ExpandoValue> orderByComparator)
1109                    throws com.liferay.portlet.expando.NoSuchValueException {
1110                    return getPersistence()
1111                                       .findByC_C_Last(classNameId, classPK, orderByComparator);
1112            }
1113    
1114            /**
1115            * Returns the last expando value in the ordered set where classNameId = &#63; and classPK = &#63;.
1116            *
1117            * @param classNameId the class name ID
1118            * @param classPK the class p k
1119            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1120            * @return the last matching expando value, or <code>null</code> if a matching expando value could not be found
1121            */
1122            public static ExpandoValue fetchByC_C_Last(long classNameId, long classPK,
1123                    OrderByComparator<ExpandoValue> orderByComparator) {
1124                    return getPersistence()
1125                                       .fetchByC_C_Last(classNameId, classPK, orderByComparator);
1126            }
1127    
1128            /**
1129            * Returns the expando values before and after the current expando value in the ordered set where classNameId = &#63; and classPK = &#63;.
1130            *
1131            * @param valueId the primary key of the current expando value
1132            * @param classNameId the class name ID
1133            * @param classPK the class p k
1134            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1135            * @return the previous, current, and next expando value
1136            * @throws NoSuchValueException if a expando value with the primary key could not be found
1137            */
1138            public static ExpandoValue[] findByC_C_PrevAndNext(long valueId,
1139                    long classNameId, long classPK,
1140                    OrderByComparator<ExpandoValue> orderByComparator)
1141                    throws com.liferay.portlet.expando.NoSuchValueException {
1142                    return getPersistence()
1143                                       .findByC_C_PrevAndNext(valueId, classNameId, classPK,
1144                            orderByComparator);
1145            }
1146    
1147            /**
1148            * Removes all the expando values where classNameId = &#63; and classPK = &#63; from the database.
1149            *
1150            * @param classNameId the class name ID
1151            * @param classPK the class p k
1152            */
1153            public static void removeByC_C(long classNameId, long classPK) {
1154                    getPersistence().removeByC_C(classNameId, classPK);
1155            }
1156    
1157            /**
1158            * Returns the number of expando values where classNameId = &#63; and classPK = &#63;.
1159            *
1160            * @param classNameId the class name ID
1161            * @param classPK the class p k
1162            * @return the number of matching expando values
1163            */
1164            public static int countByC_C(long classNameId, long classPK) {
1165                    return getPersistence().countByC_C(classNameId, classPK);
1166            }
1167    
1168            /**
1169            * Returns the expando value where tableId = &#63; and columnId = &#63; and classPK = &#63; or throws a {@link NoSuchValueException} if it could not be found.
1170            *
1171            * @param tableId the table ID
1172            * @param columnId the column ID
1173            * @param classPK the class p k
1174            * @return the matching expando value
1175            * @throws NoSuchValueException if a matching expando value could not be found
1176            */
1177            public static ExpandoValue findByT_C_C(long tableId, long columnId,
1178                    long classPK) throws com.liferay.portlet.expando.NoSuchValueException {
1179                    return getPersistence().findByT_C_C(tableId, columnId, classPK);
1180            }
1181    
1182            /**
1183            * 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.
1184            *
1185            * @param tableId the table ID
1186            * @param columnId the column ID
1187            * @param classPK the class p k
1188            * @return the matching expando value, or <code>null</code> if a matching expando value could not be found
1189            */
1190            public static ExpandoValue fetchByT_C_C(long tableId, long columnId,
1191                    long classPK) {
1192                    return getPersistence().fetchByT_C_C(tableId, columnId, classPK);
1193            }
1194    
1195            /**
1196            * 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.
1197            *
1198            * @param tableId the table ID
1199            * @param columnId the column ID
1200            * @param classPK the class p k
1201            * @param retrieveFromCache whether to use the finder cache
1202            * @return the matching expando value, or <code>null</code> if a matching expando value could not be found
1203            */
1204            public static ExpandoValue fetchByT_C_C(long tableId, long columnId,
1205                    long classPK, boolean retrieveFromCache) {
1206                    return getPersistence()
1207                                       .fetchByT_C_C(tableId, columnId, classPK, retrieveFromCache);
1208            }
1209    
1210            /**
1211            * Removes the expando value where tableId = &#63; and columnId = &#63; and classPK = &#63; from the database.
1212            *
1213            * @param tableId the table ID
1214            * @param columnId the column ID
1215            * @param classPK the class p k
1216            * @return the expando value that was removed
1217            */
1218            public static ExpandoValue removeByT_C_C(long tableId, long columnId,
1219                    long classPK) throws com.liferay.portlet.expando.NoSuchValueException {
1220                    return getPersistence().removeByT_C_C(tableId, columnId, classPK);
1221            }
1222    
1223            /**
1224            * Returns the number of expando values where tableId = &#63; and columnId = &#63; and classPK = &#63;.
1225            *
1226            * @param tableId the table ID
1227            * @param columnId the column ID
1228            * @param classPK the class p k
1229            * @return the number of matching expando values
1230            */
1231            public static int countByT_C_C(long tableId, long columnId, long classPK) {
1232                    return getPersistence().countByT_C_C(tableId, columnId, classPK);
1233            }
1234    
1235            /**
1236            * Returns all the expando values where tableId = &#63; and columnId = &#63; and data = &#63;.
1237            *
1238            * @param tableId the table ID
1239            * @param columnId the column ID
1240            * @param data the data
1241            * @return the matching expando values
1242            */
1243            public static List<ExpandoValue> findByT_C_D(long tableId, long columnId,
1244                    java.lang.String data) {
1245                    return getPersistence().findByT_C_D(tableId, columnId, data);
1246            }
1247    
1248            /**
1249            * Returns a range of all the expando values where tableId = &#63; and columnId = &#63; and data = &#63;.
1250            *
1251            * <p>
1252            * 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.
1253            * </p>
1254            *
1255            * @param tableId the table ID
1256            * @param columnId the column ID
1257            * @param data the data
1258            * @param start the lower bound of the range of expando values
1259            * @param end the upper bound of the range of expando values (not inclusive)
1260            * @return the range of matching expando values
1261            */
1262            public static List<ExpandoValue> findByT_C_D(long tableId, long columnId,
1263                    java.lang.String data, int start, int end) {
1264                    return getPersistence().findByT_C_D(tableId, columnId, data, start, end);
1265            }
1266    
1267            /**
1268            * Returns an ordered range of all the expando values where tableId = &#63; and columnId = &#63; and data = &#63;.
1269            *
1270            * <p>
1271            * 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.
1272            * </p>
1273            *
1274            * @param tableId the table ID
1275            * @param columnId the column ID
1276            * @param data the data
1277            * @param start the lower bound of the range of expando values
1278            * @param end the upper bound of the range of expando values (not inclusive)
1279            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1280            * @return the ordered range of matching expando values
1281            */
1282            public static List<ExpandoValue> findByT_C_D(long tableId, long columnId,
1283                    java.lang.String data, int start, int end,
1284                    OrderByComparator<ExpandoValue> orderByComparator) {
1285                    return getPersistence()
1286                                       .findByT_C_D(tableId, columnId, data, start, end,
1287                            orderByComparator);
1288            }
1289    
1290            /**
1291            * Returns the first expando value in the ordered set where tableId = &#63; and columnId = &#63; and data = &#63;.
1292            *
1293            * @param tableId the table ID
1294            * @param columnId the column ID
1295            * @param data the data
1296            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1297            * @return the first matching expando value
1298            * @throws NoSuchValueException if a matching expando value could not be found
1299            */
1300            public static ExpandoValue findByT_C_D_First(long tableId, long columnId,
1301                    java.lang.String data, OrderByComparator<ExpandoValue> orderByComparator)
1302                    throws com.liferay.portlet.expando.NoSuchValueException {
1303                    return getPersistence()
1304                                       .findByT_C_D_First(tableId, columnId, data, orderByComparator);
1305            }
1306    
1307            /**
1308            * Returns the first expando value in the ordered set where tableId = &#63; and columnId = &#63; and data = &#63;.
1309            *
1310            * @param tableId the table ID
1311            * @param columnId the column ID
1312            * @param data the data
1313            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1314            * @return the first matching expando value, or <code>null</code> if a matching expando value could not be found
1315            */
1316            public static ExpandoValue fetchByT_C_D_First(long tableId, long columnId,
1317                    java.lang.String data, OrderByComparator<ExpandoValue> orderByComparator) {
1318                    return getPersistence()
1319                                       .fetchByT_C_D_First(tableId, columnId, data,
1320                            orderByComparator);
1321            }
1322    
1323            /**
1324            * Returns the last expando value in the ordered set where tableId = &#63; and columnId = &#63; and data = &#63;.
1325            *
1326            * @param tableId the table ID
1327            * @param columnId the column ID
1328            * @param data the data
1329            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1330            * @return the last matching expando value
1331            * @throws NoSuchValueException if a matching expando value could not be found
1332            */
1333            public static ExpandoValue findByT_C_D_Last(long tableId, long columnId,
1334                    java.lang.String data, OrderByComparator<ExpandoValue> orderByComparator)
1335                    throws com.liferay.portlet.expando.NoSuchValueException {
1336                    return getPersistence()
1337                                       .findByT_C_D_Last(tableId, columnId, data, orderByComparator);
1338            }
1339    
1340            /**
1341            * Returns the last expando value in the ordered set where tableId = &#63; and columnId = &#63; and data = &#63;.
1342            *
1343            * @param tableId the table ID
1344            * @param columnId the column ID
1345            * @param data the data
1346            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1347            * @return the last matching expando value, or <code>null</code> if a matching expando value could not be found
1348            */
1349            public static ExpandoValue fetchByT_C_D_Last(long tableId, long columnId,
1350                    java.lang.String data, OrderByComparator<ExpandoValue> orderByComparator) {
1351                    return getPersistence()
1352                                       .fetchByT_C_D_Last(tableId, columnId, data, orderByComparator);
1353            }
1354    
1355            /**
1356            * Returns the expando values before and after the current expando value in the ordered set where tableId = &#63; and columnId = &#63; and data = &#63;.
1357            *
1358            * @param valueId the primary key of the current expando value
1359            * @param tableId the table ID
1360            * @param columnId the column ID
1361            * @param data the data
1362            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1363            * @return the previous, current, and next expando value
1364            * @throws NoSuchValueException if a expando value with the primary key could not be found
1365            */
1366            public static ExpandoValue[] findByT_C_D_PrevAndNext(long valueId,
1367                    long tableId, long columnId, java.lang.String data,
1368                    OrderByComparator<ExpandoValue> orderByComparator)
1369                    throws com.liferay.portlet.expando.NoSuchValueException {
1370                    return getPersistence()
1371                                       .findByT_C_D_PrevAndNext(valueId, tableId, columnId, data,
1372                            orderByComparator);
1373            }
1374    
1375            /**
1376            * Removes all the expando values where tableId = &#63; and columnId = &#63; and data = &#63; from the database.
1377            *
1378            * @param tableId the table ID
1379            * @param columnId the column ID
1380            * @param data the data
1381            */
1382            public static void removeByT_C_D(long tableId, long columnId,
1383                    java.lang.String data) {
1384                    getPersistence().removeByT_C_D(tableId, columnId, data);
1385            }
1386    
1387            /**
1388            * Returns the number of expando values where tableId = &#63; and columnId = &#63; and data = &#63;.
1389            *
1390            * @param tableId the table ID
1391            * @param columnId the column ID
1392            * @param data the data
1393            * @return the number of matching expando values
1394            */
1395            public static int countByT_C_D(long tableId, long columnId,
1396                    java.lang.String data) {
1397                    return getPersistence().countByT_C_D(tableId, columnId, data);
1398            }
1399    
1400            /**
1401            * Caches the expando value in the entity cache if it is enabled.
1402            *
1403            * @param expandoValue the expando value
1404            */
1405            public static void cacheResult(ExpandoValue expandoValue) {
1406                    getPersistence().cacheResult(expandoValue);
1407            }
1408    
1409            /**
1410            * Caches the expando values in the entity cache if it is enabled.
1411            *
1412            * @param expandoValues the expando values
1413            */
1414            public static void cacheResult(List<ExpandoValue> expandoValues) {
1415                    getPersistence().cacheResult(expandoValues);
1416            }
1417    
1418            /**
1419            * Creates a new expando value with the primary key. Does not add the expando value to the database.
1420            *
1421            * @param valueId the primary key for the new expando value
1422            * @return the new expando value
1423            */
1424            public static ExpandoValue create(long valueId) {
1425                    return getPersistence().create(valueId);
1426            }
1427    
1428            /**
1429            * Removes the expando value with the primary key from the database. Also notifies the appropriate model listeners.
1430            *
1431            * @param valueId the primary key of the expando value
1432            * @return the expando value that was removed
1433            * @throws NoSuchValueException if a expando value with the primary key could not be found
1434            */
1435            public static ExpandoValue remove(long valueId)
1436                    throws com.liferay.portlet.expando.NoSuchValueException {
1437                    return getPersistence().remove(valueId);
1438            }
1439    
1440            public static ExpandoValue updateImpl(ExpandoValue expandoValue) {
1441                    return getPersistence().updateImpl(expandoValue);
1442            }
1443    
1444            /**
1445            * Returns the expando value with the primary key or throws a {@link NoSuchValueException} if it could not be found.
1446            *
1447            * @param valueId the primary key of the expando value
1448            * @return the expando value
1449            * @throws NoSuchValueException if a expando value with the primary key could not be found
1450            */
1451            public static ExpandoValue findByPrimaryKey(long valueId)
1452                    throws com.liferay.portlet.expando.NoSuchValueException {
1453                    return getPersistence().findByPrimaryKey(valueId);
1454            }
1455    
1456            /**
1457            * Returns the expando value with the primary key or returns <code>null</code> if it could not be found.
1458            *
1459            * @param valueId the primary key of the expando value
1460            * @return the expando value, or <code>null</code> if a expando value with the primary key could not be found
1461            */
1462            public static ExpandoValue fetchByPrimaryKey(long valueId) {
1463                    return getPersistence().fetchByPrimaryKey(valueId);
1464            }
1465    
1466            public static java.util.Map<java.io.Serializable, ExpandoValue> fetchByPrimaryKeys(
1467                    java.util.Set<java.io.Serializable> primaryKeys) {
1468                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
1469            }
1470    
1471            /**
1472            * Returns all the expando values.
1473            *
1474            * @return the expando values
1475            */
1476            public static List<ExpandoValue> findAll() {
1477                    return getPersistence().findAll();
1478            }
1479    
1480            /**
1481            * Returns a range of all the expando values.
1482            *
1483            * <p>
1484            * 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.
1485            * </p>
1486            *
1487            * @param start the lower bound of the range of expando values
1488            * @param end the upper bound of the range of expando values (not inclusive)
1489            * @return the range of expando values
1490            */
1491            public static List<ExpandoValue> findAll(int start, int end) {
1492                    return getPersistence().findAll(start, end);
1493            }
1494    
1495            /**
1496            * Returns an ordered range of all the expando values.
1497            *
1498            * <p>
1499            * 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.
1500            * </p>
1501            *
1502            * @param start the lower bound of the range of expando values
1503            * @param end the upper bound of the range of expando values (not inclusive)
1504            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1505            * @return the ordered range of expando values
1506            */
1507            public static List<ExpandoValue> findAll(int start, int end,
1508                    OrderByComparator<ExpandoValue> orderByComparator) {
1509                    return getPersistence().findAll(start, end, orderByComparator);
1510            }
1511    
1512            /**
1513            * Removes all the expando values from the database.
1514            */
1515            public static void removeAll() {
1516                    getPersistence().removeAll();
1517            }
1518    
1519            /**
1520            * Returns the number of expando values.
1521            *
1522            * @return the number of expando values
1523            */
1524            public static int countAll() {
1525                    return getPersistence().countAll();
1526            }
1527    
1528            public static ExpandoValuePersistence getPersistence() {
1529                    if (_persistence == null) {
1530                            _persistence = (ExpandoValuePersistence)PortalBeanLocatorUtil.locate(ExpandoValuePersistence.class.getName());
1531    
1532                            ReferenceRegistry.registerReference(ExpandoValueUtil.class,
1533                                    "_persistence");
1534                    }
1535    
1536                    return _persistence;
1537            }
1538    
1539            /**
1540             * @deprecated As of 6.2.0
1541             */
1542            @Deprecated
1543            public void setPersistence(ExpandoValuePersistence persistence) {
1544            }
1545    
1546            private static ExpandoValuePersistence _persistence;
1547    }