001    /**
002     * Copyright (c) 2000-2012 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.dynamicdatamapping.service.persistence;
016    
017    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
018    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
019    import com.liferay.portal.kernel.exception.SystemException;
020    import com.liferay.portal.kernel.util.OrderByComparator;
021    import com.liferay.portal.kernel.util.ReferenceRegistry;
022    import com.liferay.portal.service.ServiceContext;
023    
024    import com.liferay.portlet.dynamicdatamapping.model.DDMStructure;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the d d m structure service. This utility wraps {@link DDMStructurePersistenceImpl} 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.
030     *
031     * <p>
032     * Caching information and settings can be found in <code>portal.properties</code>
033     * </p>
034     *
035     * @author Brian Wing Shun Chan
036     * @see DDMStructurePersistence
037     * @see DDMStructurePersistenceImpl
038     * @generated
039     */
040    public class DDMStructureUtil {
041            /*
042             * NOTE FOR DEVELOPERS:
043             *
044             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
045             */
046    
047            /**
048             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
049             */
050            public static void clearCache() {
051                    getPersistence().clearCache();
052            }
053    
054            /**
055             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
056             */
057            public static void clearCache(DDMStructure ddmStructure) {
058                    getPersistence().clearCache(ddmStructure);
059            }
060    
061            /**
062             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
063             */
064            public long countWithDynamicQuery(DynamicQuery dynamicQuery)
065                    throws SystemException {
066                    return getPersistence().countWithDynamicQuery(dynamicQuery);
067            }
068    
069            /**
070             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
071             */
072            public static List<DDMStructure> findWithDynamicQuery(
073                    DynamicQuery dynamicQuery) throws SystemException {
074                    return getPersistence().findWithDynamicQuery(dynamicQuery);
075            }
076    
077            /**
078             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
079             */
080            public static List<DDMStructure> findWithDynamicQuery(
081                    DynamicQuery dynamicQuery, int start, int end)
082                    throws SystemException {
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<DDMStructure> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator orderByComparator) throws SystemException {
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 DDMStructure update(DDMStructure ddmStructure)
101                    throws SystemException {
102                    return getPersistence().update(ddmStructure);
103            }
104    
105            /**
106             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
107             */
108            public static DDMStructure update(DDMStructure ddmStructure,
109                    ServiceContext serviceContext) throws SystemException {
110                    return getPersistence().update(ddmStructure, serviceContext);
111            }
112    
113            /**
114            * Returns all the d d m structures where uuid = &#63;.
115            *
116            * @param uuid the uuid
117            * @return the matching d d m structures
118            * @throws SystemException if a system exception occurred
119            */
120            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByUuid(
121                    java.lang.String uuid)
122                    throws com.liferay.portal.kernel.exception.SystemException {
123                    return getPersistence().findByUuid(uuid);
124            }
125    
126            /**
127            * Returns a range of all the d d m structures where uuid = &#63;.
128            *
129            * <p>
130            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
131            * </p>
132            *
133            * @param uuid the uuid
134            * @param start the lower bound of the range of d d m structures
135            * @param end the upper bound of the range of d d m structures (not inclusive)
136            * @return the range of matching d d m structures
137            * @throws SystemException if a system exception occurred
138            */
139            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByUuid(
140                    java.lang.String uuid, int start, int end)
141                    throws com.liferay.portal.kernel.exception.SystemException {
142                    return getPersistence().findByUuid(uuid, start, end);
143            }
144    
145            /**
146            * Returns an ordered range of all the d d m structures where uuid = &#63;.
147            *
148            * <p>
149            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
150            * </p>
151            *
152            * @param uuid the uuid
153            * @param start the lower bound of the range of d d m structures
154            * @param end the upper bound of the range of d d m structures (not inclusive)
155            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
156            * @return the ordered range of matching d d m structures
157            * @throws SystemException if a system exception occurred
158            */
159            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByUuid(
160                    java.lang.String uuid, int start, int end,
161                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
162                    throws com.liferay.portal.kernel.exception.SystemException {
163                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
164            }
165    
166            /**
167            * Returns the first d d m structure in the ordered set where uuid = &#63;.
168            *
169            * @param uuid the uuid
170            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
171            * @return the first matching d d m structure
172            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
173            * @throws SystemException if a system exception occurred
174            */
175            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByUuid_First(
176                    java.lang.String uuid,
177                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
178                    throws com.liferay.portal.kernel.exception.SystemException,
179                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
180                    return getPersistence().findByUuid_First(uuid, orderByComparator);
181            }
182    
183            /**
184            * Returns the first d d m structure in the ordered set where uuid = &#63;.
185            *
186            * @param uuid the uuid
187            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
188            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
189            * @throws SystemException if a system exception occurred
190            */
191            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByUuid_First(
192                    java.lang.String uuid,
193                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
194                    throws com.liferay.portal.kernel.exception.SystemException {
195                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
196            }
197    
198            /**
199            * Returns the last d d m structure in the ordered set where uuid = &#63;.
200            *
201            * @param uuid the uuid
202            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
203            * @return the last matching d d m structure
204            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
205            * @throws SystemException if a system exception occurred
206            */
207            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByUuid_Last(
208                    java.lang.String uuid,
209                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
210                    throws com.liferay.portal.kernel.exception.SystemException,
211                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
212                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
213            }
214    
215            /**
216            * Returns the last d d m structure in the ordered set where uuid = &#63;.
217            *
218            * @param uuid the uuid
219            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
220            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
221            * @throws SystemException if a system exception occurred
222            */
223            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByUuid_Last(
224                    java.lang.String uuid,
225                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
226                    throws com.liferay.portal.kernel.exception.SystemException {
227                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
228            }
229    
230            /**
231            * Returns the d d m structures before and after the current d d m structure in the ordered set where uuid = &#63;.
232            *
233            * @param structureId the primary key of the current d d m structure
234            * @param uuid the uuid
235            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
236            * @return the previous, current, and next d d m structure
237            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
238            * @throws SystemException if a system exception occurred
239            */
240            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByUuid_PrevAndNext(
241                    long structureId, java.lang.String uuid,
242                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
243                    throws com.liferay.portal.kernel.exception.SystemException,
244                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
245                    return getPersistence()
246                                       .findByUuid_PrevAndNext(structureId, uuid, orderByComparator);
247            }
248    
249            /**
250            * Removes all the d d m structures where uuid = &#63; from the database.
251            *
252            * @param uuid the uuid
253            * @throws SystemException if a system exception occurred
254            */
255            public static void removeByUuid(java.lang.String uuid)
256                    throws com.liferay.portal.kernel.exception.SystemException {
257                    getPersistence().removeByUuid(uuid);
258            }
259    
260            /**
261            * Returns the number of d d m structures where uuid = &#63;.
262            *
263            * @param uuid the uuid
264            * @return the number of matching d d m structures
265            * @throws SystemException if a system exception occurred
266            */
267            public static int countByUuid(java.lang.String uuid)
268                    throws com.liferay.portal.kernel.exception.SystemException {
269                    return getPersistence().countByUuid(uuid);
270            }
271    
272            /**
273            * Returns the d d m structure where uuid = &#63; and groupId = &#63; or throws a {@link com.liferay.portlet.dynamicdatamapping.NoSuchStructureException} if it could not be found.
274            *
275            * @param uuid the uuid
276            * @param groupId the group ID
277            * @return the matching d d m structure
278            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
279            * @throws SystemException if a system exception occurred
280            */
281            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByUUID_G(
282                    java.lang.String uuid, long groupId)
283                    throws com.liferay.portal.kernel.exception.SystemException,
284                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
285                    return getPersistence().findByUUID_G(uuid, groupId);
286            }
287    
288            /**
289            * Returns the d d m structure where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
290            *
291            * @param uuid the uuid
292            * @param groupId the group ID
293            * @return the matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
294            * @throws SystemException if a system exception occurred
295            */
296            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByUUID_G(
297                    java.lang.String uuid, long groupId)
298                    throws com.liferay.portal.kernel.exception.SystemException {
299                    return getPersistence().fetchByUUID_G(uuid, groupId);
300            }
301    
302            /**
303            * Returns the d d m structure where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
304            *
305            * @param uuid the uuid
306            * @param groupId the group ID
307            * @param retrieveFromCache whether to use the finder cache
308            * @return the matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
309            * @throws SystemException if a system exception occurred
310            */
311            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByUUID_G(
312                    java.lang.String uuid, long groupId, boolean retrieveFromCache)
313                    throws com.liferay.portal.kernel.exception.SystemException {
314                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
315            }
316    
317            /**
318            * Removes the d d m structure where uuid = &#63; and groupId = &#63; from the database.
319            *
320            * @param uuid the uuid
321            * @param groupId the group ID
322            * @return the d d m structure that was removed
323            * @throws SystemException if a system exception occurred
324            */
325            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure removeByUUID_G(
326                    java.lang.String uuid, long groupId)
327                    throws com.liferay.portal.kernel.exception.SystemException,
328                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
329                    return getPersistence().removeByUUID_G(uuid, groupId);
330            }
331    
332            /**
333            * Returns the number of d d m structures where uuid = &#63; and groupId = &#63;.
334            *
335            * @param uuid the uuid
336            * @param groupId the group ID
337            * @return the number of matching d d m structures
338            * @throws SystemException if a system exception occurred
339            */
340            public static int countByUUID_G(java.lang.String uuid, long groupId)
341                    throws com.liferay.portal.kernel.exception.SystemException {
342                    return getPersistence().countByUUID_G(uuid, groupId);
343            }
344    
345            /**
346            * Returns all the d d m structures where uuid = &#63; and companyId = &#63;.
347            *
348            * @param uuid the uuid
349            * @param companyId the company ID
350            * @return the matching d d m structures
351            * @throws SystemException if a system exception occurred
352            */
353            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByUuid_C(
354                    java.lang.String uuid, long companyId)
355                    throws com.liferay.portal.kernel.exception.SystemException {
356                    return getPersistence().findByUuid_C(uuid, companyId);
357            }
358    
359            /**
360            * Returns a range of all the d d m structures where uuid = &#63; and companyId = &#63;.
361            *
362            * <p>
363            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
364            * </p>
365            *
366            * @param uuid the uuid
367            * @param companyId the company ID
368            * @param start the lower bound of the range of d d m structures
369            * @param end the upper bound of the range of d d m structures (not inclusive)
370            * @return the range of matching d d m structures
371            * @throws SystemException if a system exception occurred
372            */
373            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByUuid_C(
374                    java.lang.String uuid, long companyId, int start, int end)
375                    throws com.liferay.portal.kernel.exception.SystemException {
376                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
377            }
378    
379            /**
380            * Returns an ordered range of all the d d m structures where uuid = &#63; and companyId = &#63;.
381            *
382            * <p>
383            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
384            * </p>
385            *
386            * @param uuid the uuid
387            * @param companyId the company ID
388            * @param start the lower bound of the range of d d m structures
389            * @param end the upper bound of the range of d d m structures (not inclusive)
390            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
391            * @return the ordered range of matching d d m structures
392            * @throws SystemException if a system exception occurred
393            */
394            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByUuid_C(
395                    java.lang.String uuid, long companyId, int start, int end,
396                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
397                    throws com.liferay.portal.kernel.exception.SystemException {
398                    return getPersistence()
399                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
400            }
401    
402            /**
403            * Returns the first d d m structure in the ordered set where uuid = &#63; and companyId = &#63;.
404            *
405            * @param uuid the uuid
406            * @param companyId the company ID
407            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
408            * @return the first matching d d m structure
409            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
410            * @throws SystemException if a system exception occurred
411            */
412            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByUuid_C_First(
413                    java.lang.String uuid, long companyId,
414                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
415                    throws com.liferay.portal.kernel.exception.SystemException,
416                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
417                    return getPersistence()
418                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
419            }
420    
421            /**
422            * Returns the first d d m structure in the ordered set where uuid = &#63; and companyId = &#63;.
423            *
424            * @param uuid the uuid
425            * @param companyId the company ID
426            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
427            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
428            * @throws SystemException if a system exception occurred
429            */
430            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByUuid_C_First(
431                    java.lang.String uuid, long companyId,
432                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
433                    throws com.liferay.portal.kernel.exception.SystemException {
434                    return getPersistence()
435                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
436            }
437    
438            /**
439            * Returns the last d d m structure in the ordered set where uuid = &#63; and companyId = &#63;.
440            *
441            * @param uuid the uuid
442            * @param companyId the company ID
443            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
444            * @return the last matching d d m structure
445            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
446            * @throws SystemException if a system exception occurred
447            */
448            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByUuid_C_Last(
449                    java.lang.String uuid, long companyId,
450                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
451                    throws com.liferay.portal.kernel.exception.SystemException,
452                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
453                    return getPersistence()
454                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
455            }
456    
457            /**
458            * Returns the last d d m structure in the ordered set where uuid = &#63; and companyId = &#63;.
459            *
460            * @param uuid the uuid
461            * @param companyId the company ID
462            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
463            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
464            * @throws SystemException if a system exception occurred
465            */
466            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByUuid_C_Last(
467                    java.lang.String uuid, long companyId,
468                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
469                    throws com.liferay.portal.kernel.exception.SystemException {
470                    return getPersistence()
471                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
472            }
473    
474            /**
475            * Returns the d d m structures before and after the current d d m structure in the ordered set where uuid = &#63; and companyId = &#63;.
476            *
477            * @param structureId the primary key of the current d d m structure
478            * @param uuid the uuid
479            * @param companyId the company ID
480            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
481            * @return the previous, current, and next d d m structure
482            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
483            * @throws SystemException if a system exception occurred
484            */
485            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByUuid_C_PrevAndNext(
486                    long structureId, java.lang.String uuid, long companyId,
487                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
488                    throws com.liferay.portal.kernel.exception.SystemException,
489                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
490                    return getPersistence()
491                                       .findByUuid_C_PrevAndNext(structureId, uuid, companyId,
492                            orderByComparator);
493            }
494    
495            /**
496            * Removes all the d d m structures where uuid = &#63; and companyId = &#63; from the database.
497            *
498            * @param uuid the uuid
499            * @param companyId the company ID
500            * @throws SystemException if a system exception occurred
501            */
502            public static void removeByUuid_C(java.lang.String uuid, long companyId)
503                    throws com.liferay.portal.kernel.exception.SystemException {
504                    getPersistence().removeByUuid_C(uuid, companyId);
505            }
506    
507            /**
508            * Returns the number of d d m structures where uuid = &#63; and companyId = &#63;.
509            *
510            * @param uuid the uuid
511            * @param companyId the company ID
512            * @return the number of matching d d m structures
513            * @throws SystemException if a system exception occurred
514            */
515            public static int countByUuid_C(java.lang.String uuid, long companyId)
516                    throws com.liferay.portal.kernel.exception.SystemException {
517                    return getPersistence().countByUuid_C(uuid, companyId);
518            }
519    
520            /**
521            * Returns all the d d m structures where groupId = &#63;.
522            *
523            * @param groupId the group ID
524            * @return the matching d d m structures
525            * @throws SystemException if a system exception occurred
526            */
527            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByGroupId(
528                    long groupId)
529                    throws com.liferay.portal.kernel.exception.SystemException {
530                    return getPersistence().findByGroupId(groupId);
531            }
532    
533            /**
534            * Returns a range of all the d d m structures where groupId = &#63;.
535            *
536            * <p>
537            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
538            * </p>
539            *
540            * @param groupId the group ID
541            * @param start the lower bound of the range of d d m structures
542            * @param end the upper bound of the range of d d m structures (not inclusive)
543            * @return the range of matching d d m structures
544            * @throws SystemException if a system exception occurred
545            */
546            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByGroupId(
547                    long groupId, int start, int end)
548                    throws com.liferay.portal.kernel.exception.SystemException {
549                    return getPersistence().findByGroupId(groupId, start, end);
550            }
551    
552            /**
553            * Returns an ordered range of all the d d m structures where groupId = &#63;.
554            *
555            * <p>
556            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
557            * </p>
558            *
559            * @param groupId the group ID
560            * @param start the lower bound of the range of d d m structures
561            * @param end the upper bound of the range of d d m structures (not inclusive)
562            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
563            * @return the ordered range of matching d d m structures
564            * @throws SystemException if a system exception occurred
565            */
566            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByGroupId(
567                    long groupId, int start, int end,
568                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
569                    throws com.liferay.portal.kernel.exception.SystemException {
570                    return getPersistence()
571                                       .findByGroupId(groupId, start, end, orderByComparator);
572            }
573    
574            /**
575            * Returns the first d d m structure in the ordered set where groupId = &#63;.
576            *
577            * @param groupId the group ID
578            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
579            * @return the first matching d d m structure
580            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
581            * @throws SystemException if a system exception occurred
582            */
583            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByGroupId_First(
584                    long groupId,
585                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
586                    throws com.liferay.portal.kernel.exception.SystemException,
587                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
588                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
589            }
590    
591            /**
592            * Returns the first d d m structure in the ordered set where groupId = &#63;.
593            *
594            * @param groupId the group ID
595            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
596            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
597            * @throws SystemException if a system exception occurred
598            */
599            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByGroupId_First(
600                    long groupId,
601                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
602                    throws com.liferay.portal.kernel.exception.SystemException {
603                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
604            }
605    
606            /**
607            * Returns the last d d m structure in the ordered set where groupId = &#63;.
608            *
609            * @param groupId the group ID
610            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
611            * @return the last matching d d m structure
612            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
613            * @throws SystemException if a system exception occurred
614            */
615            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByGroupId_Last(
616                    long groupId,
617                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
618                    throws com.liferay.portal.kernel.exception.SystemException,
619                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
620                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
621            }
622    
623            /**
624            * Returns the last d d m structure in the ordered set where groupId = &#63;.
625            *
626            * @param groupId the group ID
627            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
628            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
629            * @throws SystemException if a system exception occurred
630            */
631            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByGroupId_Last(
632                    long groupId,
633                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
634                    throws com.liferay.portal.kernel.exception.SystemException {
635                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
636            }
637    
638            /**
639            * Returns the d d m structures before and after the current d d m structure in the ordered set where groupId = &#63;.
640            *
641            * @param structureId the primary key of the current d d m structure
642            * @param groupId the group ID
643            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
644            * @return the previous, current, and next d d m structure
645            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
646            * @throws SystemException if a system exception occurred
647            */
648            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByGroupId_PrevAndNext(
649                    long structureId, long groupId,
650                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
651                    throws com.liferay.portal.kernel.exception.SystemException,
652                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
653                    return getPersistence()
654                                       .findByGroupId_PrevAndNext(structureId, groupId,
655                            orderByComparator);
656            }
657    
658            /**
659            * Returns all the d d m structures that the user has permission to view where groupId = &#63;.
660            *
661            * @param groupId the group ID
662            * @return the matching d d m structures that the user has permission to view
663            * @throws SystemException if a system exception occurred
664            */
665            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByGroupId(
666                    long groupId)
667                    throws com.liferay.portal.kernel.exception.SystemException {
668                    return getPersistence().filterFindByGroupId(groupId);
669            }
670    
671            /**
672            * Returns a range of all the d d m structures that the user has permission to view where groupId = &#63;.
673            *
674            * <p>
675            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
676            * </p>
677            *
678            * @param groupId the group ID
679            * @param start the lower bound of the range of d d m structures
680            * @param end the upper bound of the range of d d m structures (not inclusive)
681            * @return the range of matching d d m structures that the user has permission to view
682            * @throws SystemException if a system exception occurred
683            */
684            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByGroupId(
685                    long groupId, int start, int end)
686                    throws com.liferay.portal.kernel.exception.SystemException {
687                    return getPersistence().filterFindByGroupId(groupId, start, end);
688            }
689    
690            /**
691            * Returns an ordered range of all the d d m structures that the user has permissions to view where groupId = &#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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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 groupId the group ID
698            * @param start the lower bound of the range of d d m structures
699            * @param end the upper bound of the range of d d m structures (not inclusive)
700            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
701            * @return the ordered range of matching d d m structures that the user has permission to view
702            * @throws SystemException if a system exception occurred
703            */
704            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByGroupId(
705                    long groupId, int start, int end,
706                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
707                    throws com.liferay.portal.kernel.exception.SystemException {
708                    return getPersistence()
709                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
710            }
711    
712            /**
713            * Returns the d d m structures before and after the current d d m structure in the ordered set of d d m structures that the user has permission to view where groupId = &#63;.
714            *
715            * @param structureId the primary key of the current d d m structure
716            * @param groupId the group ID
717            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
718            * @return the previous, current, and next d d m structure
719            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
720            * @throws SystemException if a system exception occurred
721            */
722            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] filterFindByGroupId_PrevAndNext(
723                    long structureId, long groupId,
724                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
725                    throws com.liferay.portal.kernel.exception.SystemException,
726                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
727                    return getPersistence()
728                                       .filterFindByGroupId_PrevAndNext(structureId, groupId,
729                            orderByComparator);
730            }
731    
732            /**
733            * Returns all the d d m structures that the user has permission to view where groupId = any &#63;.
734            *
735            * @param groupIds the group IDs
736            * @return the matching d d m structures that the user has permission to view
737            * @throws SystemException if a system exception occurred
738            */
739            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByGroupId(
740                    long[] groupIds)
741                    throws com.liferay.portal.kernel.exception.SystemException {
742                    return getPersistence().filterFindByGroupId(groupIds);
743            }
744    
745            /**
746            * Returns a range of all the d d m structures that the user has permission to view where groupId = any &#63;.
747            *
748            * <p>
749            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
750            * </p>
751            *
752            * @param groupIds the group IDs
753            * @param start the lower bound of the range of d d m structures
754            * @param end the upper bound of the range of d d m structures (not inclusive)
755            * @return the range of matching d d m structures that the user has permission to view
756            * @throws SystemException if a system exception occurred
757            */
758            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByGroupId(
759                    long[] groupIds, int start, int end)
760                    throws com.liferay.portal.kernel.exception.SystemException {
761                    return getPersistence().filterFindByGroupId(groupIds, start, end);
762            }
763    
764            /**
765            * Returns an ordered range of all the d d m structures that the user has permission to view where groupId = any &#63;.
766            *
767            * <p>
768            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
769            * </p>
770            *
771            * @param groupIds the group IDs
772            * @param start the lower bound of the range of d d m structures
773            * @param end the upper bound of the range of d d m structures (not inclusive)
774            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
775            * @return the ordered range of matching d d m structures that the user has permission to view
776            * @throws SystemException if a system exception occurred
777            */
778            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByGroupId(
779                    long[] groupIds, int start, int end,
780                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
781                    throws com.liferay.portal.kernel.exception.SystemException {
782                    return getPersistence()
783                                       .filterFindByGroupId(groupIds, start, end, orderByComparator);
784            }
785    
786            /**
787            * Returns all the d d m structures where groupId = any &#63;.
788            *
789            * <p>
790            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
791            * </p>
792            *
793            * @param groupIds the group IDs
794            * @return the matching d d m structures
795            * @throws SystemException if a system exception occurred
796            */
797            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByGroupId(
798                    long[] groupIds)
799                    throws com.liferay.portal.kernel.exception.SystemException {
800                    return getPersistence().findByGroupId(groupIds);
801            }
802    
803            /**
804            * Returns a range of all the d d m structures where groupId = any &#63;.
805            *
806            * <p>
807            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
808            * </p>
809            *
810            * @param groupIds the group IDs
811            * @param start the lower bound of the range of d d m structures
812            * @param end the upper bound of the range of d d m structures (not inclusive)
813            * @return the range of matching d d m structures
814            * @throws SystemException if a system exception occurred
815            */
816            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByGroupId(
817                    long[] groupIds, int start, int end)
818                    throws com.liferay.portal.kernel.exception.SystemException {
819                    return getPersistence().findByGroupId(groupIds, start, end);
820            }
821    
822            /**
823            * Returns an ordered range of all the d d m structures where groupId = any &#63;.
824            *
825            * <p>
826            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
827            * </p>
828            *
829            * @param groupIds the group IDs
830            * @param start the lower bound of the range of d d m structures
831            * @param end the upper bound of the range of d d m structures (not inclusive)
832            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
833            * @return the ordered range of matching d d m structures
834            * @throws SystemException if a system exception occurred
835            */
836            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByGroupId(
837                    long[] groupIds, int start, int end,
838                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
839                    throws com.liferay.portal.kernel.exception.SystemException {
840                    return getPersistence()
841                                       .findByGroupId(groupIds, start, end, orderByComparator);
842            }
843    
844            /**
845            * Removes all the d d m structures where groupId = &#63; from the database.
846            *
847            * @param groupId the group ID
848            * @throws SystemException if a system exception occurred
849            */
850            public static void removeByGroupId(long groupId)
851                    throws com.liferay.portal.kernel.exception.SystemException {
852                    getPersistence().removeByGroupId(groupId);
853            }
854    
855            /**
856            * Returns the number of d d m structures where groupId = &#63;.
857            *
858            * @param groupId the group ID
859            * @return the number of matching d d m structures
860            * @throws SystemException if a system exception occurred
861            */
862            public static int countByGroupId(long groupId)
863                    throws com.liferay.portal.kernel.exception.SystemException {
864                    return getPersistence().countByGroupId(groupId);
865            }
866    
867            /**
868            * Returns the number of d d m structures where groupId = any &#63;.
869            *
870            * @param groupIds the group IDs
871            * @return the number of matching d d m structures
872            * @throws SystemException if a system exception occurred
873            */
874            public static int countByGroupId(long[] groupIds)
875                    throws com.liferay.portal.kernel.exception.SystemException {
876                    return getPersistence().countByGroupId(groupIds);
877            }
878    
879            /**
880            * Returns the number of d d m structures that the user has permission to view where groupId = &#63;.
881            *
882            * @param groupId the group ID
883            * @return the number of matching d d m structures that the user has permission to view
884            * @throws SystemException if a system exception occurred
885            */
886            public static int filterCountByGroupId(long groupId)
887                    throws com.liferay.portal.kernel.exception.SystemException {
888                    return getPersistence().filterCountByGroupId(groupId);
889            }
890    
891            /**
892            * Returns the number of d d m structures that the user has permission to view where groupId = any &#63;.
893            *
894            * @param groupIds the group IDs
895            * @return the number of matching d d m structures that the user has permission to view
896            * @throws SystemException if a system exception occurred
897            */
898            public static int filterCountByGroupId(long[] groupIds)
899                    throws com.liferay.portal.kernel.exception.SystemException {
900                    return getPersistence().filterCountByGroupId(groupIds);
901            }
902    
903            /**
904            * Returns all the d d m structures where classNameId = &#63;.
905            *
906            * @param classNameId the class name ID
907            * @return the matching d d m structures
908            * @throws SystemException if a system exception occurred
909            */
910            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByClassNameId(
911                    long classNameId)
912                    throws com.liferay.portal.kernel.exception.SystemException {
913                    return getPersistence().findByClassNameId(classNameId);
914            }
915    
916            /**
917            * Returns a range of all the d d m structures where classNameId = &#63;.
918            *
919            * <p>
920            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
921            * </p>
922            *
923            * @param classNameId the class name ID
924            * @param start the lower bound of the range of d d m structures
925            * @param end the upper bound of the range of d d m structures (not inclusive)
926            * @return the range of matching d d m structures
927            * @throws SystemException if a system exception occurred
928            */
929            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByClassNameId(
930                    long classNameId, int start, int end)
931                    throws com.liferay.portal.kernel.exception.SystemException {
932                    return getPersistence().findByClassNameId(classNameId, start, end);
933            }
934    
935            /**
936            * Returns an ordered range of all the d d m structures where classNameId = &#63;.
937            *
938            * <p>
939            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
940            * </p>
941            *
942            * @param classNameId the class name ID
943            * @param start the lower bound of the range of d d m structures
944            * @param end the upper bound of the range of d d m structures (not inclusive)
945            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
946            * @return the ordered range of matching d d m structures
947            * @throws SystemException if a system exception occurred
948            */
949            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByClassNameId(
950                    long classNameId, int start, int end,
951                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
952                    throws com.liferay.portal.kernel.exception.SystemException {
953                    return getPersistence()
954                                       .findByClassNameId(classNameId, start, end, orderByComparator);
955            }
956    
957            /**
958            * Returns the first d d m structure in the ordered set where classNameId = &#63;.
959            *
960            * @param classNameId the class name ID
961            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
962            * @return the first matching d d m structure
963            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
964            * @throws SystemException if a system exception occurred
965            */
966            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByClassNameId_First(
967                    long classNameId,
968                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
969                    throws com.liferay.portal.kernel.exception.SystemException,
970                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
971                    return getPersistence()
972                                       .findByClassNameId_First(classNameId, orderByComparator);
973            }
974    
975            /**
976            * Returns the first d d m structure in the ordered set where classNameId = &#63;.
977            *
978            * @param classNameId the class name ID
979            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
980            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
981            * @throws SystemException if a system exception occurred
982            */
983            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByClassNameId_First(
984                    long classNameId,
985                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
986                    throws com.liferay.portal.kernel.exception.SystemException {
987                    return getPersistence()
988                                       .fetchByClassNameId_First(classNameId, orderByComparator);
989            }
990    
991            /**
992            * Returns the last d d m structure in the ordered set where classNameId = &#63;.
993            *
994            * @param classNameId the class name ID
995            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
996            * @return the last matching d d m structure
997            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
998            * @throws SystemException if a system exception occurred
999            */
1000            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByClassNameId_Last(
1001                    long classNameId,
1002                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1003                    throws com.liferay.portal.kernel.exception.SystemException,
1004                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1005                    return getPersistence()
1006                                       .findByClassNameId_Last(classNameId, orderByComparator);
1007            }
1008    
1009            /**
1010            * Returns the last d d m structure in the ordered set where classNameId = &#63;.
1011            *
1012            * @param classNameId the class name ID
1013            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1014            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1015            * @throws SystemException if a system exception occurred
1016            */
1017            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByClassNameId_Last(
1018                    long classNameId,
1019                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1020                    throws com.liferay.portal.kernel.exception.SystemException {
1021                    return getPersistence()
1022                                       .fetchByClassNameId_Last(classNameId, orderByComparator);
1023            }
1024    
1025            /**
1026            * Returns the d d m structures before and after the current d d m structure in the ordered set where classNameId = &#63;.
1027            *
1028            * @param structureId the primary key of the current d d m structure
1029            * @param classNameId the class name ID
1030            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1031            * @return the previous, current, and next d d m structure
1032            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
1033            * @throws SystemException if a system exception occurred
1034            */
1035            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByClassNameId_PrevAndNext(
1036                    long structureId, long classNameId,
1037                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1038                    throws com.liferay.portal.kernel.exception.SystemException,
1039                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1040                    return getPersistence()
1041                                       .findByClassNameId_PrevAndNext(structureId, classNameId,
1042                            orderByComparator);
1043            }
1044    
1045            /**
1046            * Removes all the d d m structures where classNameId = &#63; from the database.
1047            *
1048            * @param classNameId the class name ID
1049            * @throws SystemException if a system exception occurred
1050            */
1051            public static void removeByClassNameId(long classNameId)
1052                    throws com.liferay.portal.kernel.exception.SystemException {
1053                    getPersistence().removeByClassNameId(classNameId);
1054            }
1055    
1056            /**
1057            * Returns the number of d d m structures where classNameId = &#63;.
1058            *
1059            * @param classNameId the class name ID
1060            * @return the number of matching d d m structures
1061            * @throws SystemException if a system exception occurred
1062            */
1063            public static int countByClassNameId(long classNameId)
1064                    throws com.liferay.portal.kernel.exception.SystemException {
1065                    return getPersistence().countByClassNameId(classNameId);
1066            }
1067    
1068            /**
1069            * Returns all the d d m structures where structureKey = &#63;.
1070            *
1071            * @param structureKey the structure key
1072            * @return the matching d d m structures
1073            * @throws SystemException if a system exception occurred
1074            */
1075            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByStructureKey(
1076                    java.lang.String structureKey)
1077                    throws com.liferay.portal.kernel.exception.SystemException {
1078                    return getPersistence().findByStructureKey(structureKey);
1079            }
1080    
1081            /**
1082            * Returns a range of all the d d m structures where structureKey = &#63;.
1083            *
1084            * <p>
1085            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
1086            * </p>
1087            *
1088            * @param structureKey the structure key
1089            * @param start the lower bound of the range of d d m structures
1090            * @param end the upper bound of the range of d d m structures (not inclusive)
1091            * @return the range of matching d d m structures
1092            * @throws SystemException if a system exception occurred
1093            */
1094            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByStructureKey(
1095                    java.lang.String structureKey, int start, int end)
1096                    throws com.liferay.portal.kernel.exception.SystemException {
1097                    return getPersistence().findByStructureKey(structureKey, start, end);
1098            }
1099    
1100            /**
1101            * Returns an ordered range of all the d d m structures where structureKey = &#63;.
1102            *
1103            * <p>
1104            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
1105            * </p>
1106            *
1107            * @param structureKey the structure key
1108            * @param start the lower bound of the range of d d m structures
1109            * @param end the upper bound of the range of d d m structures (not inclusive)
1110            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1111            * @return the ordered range of matching d d m structures
1112            * @throws SystemException if a system exception occurred
1113            */
1114            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByStructureKey(
1115                    java.lang.String structureKey, int start, int end,
1116                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1117                    throws com.liferay.portal.kernel.exception.SystemException {
1118                    return getPersistence()
1119                                       .findByStructureKey(structureKey, start, end,
1120                            orderByComparator);
1121            }
1122    
1123            /**
1124            * Returns the first d d m structure in the ordered set where structureKey = &#63;.
1125            *
1126            * @param structureKey the structure key
1127            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1128            * @return the first matching d d m structure
1129            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
1130            * @throws SystemException if a system exception occurred
1131            */
1132            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByStructureKey_First(
1133                    java.lang.String structureKey,
1134                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1135                    throws com.liferay.portal.kernel.exception.SystemException,
1136                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1137                    return getPersistence()
1138                                       .findByStructureKey_First(structureKey, orderByComparator);
1139            }
1140    
1141            /**
1142            * Returns the first d d m structure in the ordered set where structureKey = &#63;.
1143            *
1144            * @param structureKey the structure key
1145            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1146            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1147            * @throws SystemException if a system exception occurred
1148            */
1149            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByStructureKey_First(
1150                    java.lang.String structureKey,
1151                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1152                    throws com.liferay.portal.kernel.exception.SystemException {
1153                    return getPersistence()
1154                                       .fetchByStructureKey_First(structureKey, orderByComparator);
1155            }
1156    
1157            /**
1158            * Returns the last d d m structure in the ordered set where structureKey = &#63;.
1159            *
1160            * @param structureKey the structure key
1161            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1162            * @return the last matching d d m structure
1163            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
1164            * @throws SystemException if a system exception occurred
1165            */
1166            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByStructureKey_Last(
1167                    java.lang.String structureKey,
1168                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1169                    throws com.liferay.portal.kernel.exception.SystemException,
1170                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1171                    return getPersistence()
1172                                       .findByStructureKey_Last(structureKey, orderByComparator);
1173            }
1174    
1175            /**
1176            * Returns the last d d m structure in the ordered set where structureKey = &#63;.
1177            *
1178            * @param structureKey the structure key
1179            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1180            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1181            * @throws SystemException if a system exception occurred
1182            */
1183            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByStructureKey_Last(
1184                    java.lang.String structureKey,
1185                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1186                    throws com.liferay.portal.kernel.exception.SystemException {
1187                    return getPersistence()
1188                                       .fetchByStructureKey_Last(structureKey, orderByComparator);
1189            }
1190    
1191            /**
1192            * Returns the d d m structures before and after the current d d m structure in the ordered set where structureKey = &#63;.
1193            *
1194            * @param structureId the primary key of the current d d m structure
1195            * @param structureKey the structure key
1196            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1197            * @return the previous, current, and next d d m structure
1198            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
1199            * @throws SystemException if a system exception occurred
1200            */
1201            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByStructureKey_PrevAndNext(
1202                    long structureId, java.lang.String structureKey,
1203                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1204                    throws com.liferay.portal.kernel.exception.SystemException,
1205                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1206                    return getPersistence()
1207                                       .findByStructureKey_PrevAndNext(structureId, structureKey,
1208                            orderByComparator);
1209            }
1210    
1211            /**
1212            * Removes all the d d m structures where structureKey = &#63; from the database.
1213            *
1214            * @param structureKey the structure key
1215            * @throws SystemException if a system exception occurred
1216            */
1217            public static void removeByStructureKey(java.lang.String structureKey)
1218                    throws com.liferay.portal.kernel.exception.SystemException {
1219                    getPersistence().removeByStructureKey(structureKey);
1220            }
1221    
1222            /**
1223            * Returns the number of d d m structures where structureKey = &#63;.
1224            *
1225            * @param structureKey the structure key
1226            * @return the number of matching d d m structures
1227            * @throws SystemException if a system exception occurred
1228            */
1229            public static int countByStructureKey(java.lang.String structureKey)
1230                    throws com.liferay.portal.kernel.exception.SystemException {
1231                    return getPersistence().countByStructureKey(structureKey);
1232            }
1233    
1234            /**
1235            * Returns all the d d m structures where groupId = &#63; and classNameId = &#63;.
1236            *
1237            * @param groupId the group ID
1238            * @param classNameId the class name ID
1239            * @return the matching d d m structures
1240            * @throws SystemException if a system exception occurred
1241            */
1242            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_C(
1243                    long groupId, long classNameId)
1244                    throws com.liferay.portal.kernel.exception.SystemException {
1245                    return getPersistence().findByG_C(groupId, classNameId);
1246            }
1247    
1248            /**
1249            * Returns a range of all the d d m structures where groupId = &#63; and classNameId = &#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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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 groupId the group ID
1256            * @param classNameId the class name ID
1257            * @param start the lower bound of the range of d d m structures
1258            * @param end the upper bound of the range of d d m structures (not inclusive)
1259            * @return the range of matching d d m structures
1260            * @throws SystemException if a system exception occurred
1261            */
1262            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_C(
1263                    long groupId, long classNameId, int start, int end)
1264                    throws com.liferay.portal.kernel.exception.SystemException {
1265                    return getPersistence().findByG_C(groupId, classNameId, start, end);
1266            }
1267    
1268            /**
1269            * Returns an ordered range of all the d d m structures where groupId = &#63; and classNameId = &#63;.
1270            *
1271            * <p>
1272            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
1273            * </p>
1274            *
1275            * @param groupId the group ID
1276            * @param classNameId the class name ID
1277            * @param start the lower bound of the range of d d m structures
1278            * @param end the upper bound of the range of d d m structures (not inclusive)
1279            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1280            * @return the ordered range of matching d d m structures
1281            * @throws SystemException if a system exception occurred
1282            */
1283            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_C(
1284                    long groupId, long classNameId, int start, int end,
1285                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1286                    throws com.liferay.portal.kernel.exception.SystemException {
1287                    return getPersistence()
1288                                       .findByG_C(groupId, classNameId, start, end,
1289                            orderByComparator);
1290            }
1291    
1292            /**
1293            * Returns the first d d m structure in the ordered set where groupId = &#63; and classNameId = &#63;.
1294            *
1295            * @param groupId the group ID
1296            * @param classNameId the class name ID
1297            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1298            * @return the first matching d d m structure
1299            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
1300            * @throws SystemException if a system exception occurred
1301            */
1302            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByG_C_First(
1303                    long groupId, long classNameId,
1304                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1305                    throws com.liferay.portal.kernel.exception.SystemException,
1306                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1307                    return getPersistence()
1308                                       .findByG_C_First(groupId, classNameId, orderByComparator);
1309            }
1310    
1311            /**
1312            * Returns the first d d m structure in the ordered set where groupId = &#63; and classNameId = &#63;.
1313            *
1314            * @param groupId the group ID
1315            * @param classNameId the class name ID
1316            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1317            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1318            * @throws SystemException if a system exception occurred
1319            */
1320            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_C_First(
1321                    long groupId, long classNameId,
1322                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1323                    throws com.liferay.portal.kernel.exception.SystemException {
1324                    return getPersistence()
1325                                       .fetchByG_C_First(groupId, classNameId, orderByComparator);
1326            }
1327    
1328            /**
1329            * Returns the last d d m structure in the ordered set where groupId = &#63; and classNameId = &#63;.
1330            *
1331            * @param groupId the group ID
1332            * @param classNameId the class name ID
1333            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1334            * @return the last matching d d m structure
1335            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
1336            * @throws SystemException if a system exception occurred
1337            */
1338            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByG_C_Last(
1339                    long groupId, long classNameId,
1340                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1341                    throws com.liferay.portal.kernel.exception.SystemException,
1342                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1343                    return getPersistence()
1344                                       .findByG_C_Last(groupId, classNameId, orderByComparator);
1345            }
1346    
1347            /**
1348            * Returns the last d d m structure in the ordered set where groupId = &#63; and classNameId = &#63;.
1349            *
1350            * @param groupId the group ID
1351            * @param classNameId the class name ID
1352            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1353            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1354            * @throws SystemException if a system exception occurred
1355            */
1356            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_C_Last(
1357                    long groupId, long classNameId,
1358                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1359                    throws com.liferay.portal.kernel.exception.SystemException {
1360                    return getPersistence()
1361                                       .fetchByG_C_Last(groupId, classNameId, orderByComparator);
1362            }
1363    
1364            /**
1365            * Returns the d d m structures before and after the current d d m structure in the ordered set where groupId = &#63; and classNameId = &#63;.
1366            *
1367            * @param structureId the primary key of the current d d m structure
1368            * @param groupId the group ID
1369            * @param classNameId the class name ID
1370            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1371            * @return the previous, current, and next d d m structure
1372            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
1373            * @throws SystemException if a system exception occurred
1374            */
1375            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByG_C_PrevAndNext(
1376                    long structureId, long groupId, long classNameId,
1377                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1378                    throws com.liferay.portal.kernel.exception.SystemException,
1379                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1380                    return getPersistence()
1381                                       .findByG_C_PrevAndNext(structureId, groupId, classNameId,
1382                            orderByComparator);
1383            }
1384    
1385            /**
1386            * Returns all the d d m structures that the user has permission to view where groupId = &#63; and classNameId = &#63;.
1387            *
1388            * @param groupId the group ID
1389            * @param classNameId the class name ID
1390            * @return the matching d d m structures that the user has permission to view
1391            * @throws SystemException if a system exception occurred
1392            */
1393            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_C(
1394                    long groupId, long classNameId)
1395                    throws com.liferay.portal.kernel.exception.SystemException {
1396                    return getPersistence().filterFindByG_C(groupId, classNameId);
1397            }
1398    
1399            /**
1400            * Returns a range of all the d d m structures that the user has permission to view where groupId = &#63; and classNameId = &#63;.
1401            *
1402            * <p>
1403            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
1404            * </p>
1405            *
1406            * @param groupId the group ID
1407            * @param classNameId the class name ID
1408            * @param start the lower bound of the range of d d m structures
1409            * @param end the upper bound of the range of d d m structures (not inclusive)
1410            * @return the range of matching d d m structures that the user has permission to view
1411            * @throws SystemException if a system exception occurred
1412            */
1413            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_C(
1414                    long groupId, long classNameId, int start, int end)
1415                    throws com.liferay.portal.kernel.exception.SystemException {
1416                    return getPersistence().filterFindByG_C(groupId, classNameId, start, end);
1417            }
1418    
1419            /**
1420            * Returns an ordered range of all the d d m structures that the user has permissions to view where groupId = &#63; and classNameId = &#63;.
1421            *
1422            * <p>
1423            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
1424            * </p>
1425            *
1426            * @param groupId the group ID
1427            * @param classNameId the class name ID
1428            * @param start the lower bound of the range of d d m structures
1429            * @param end the upper bound of the range of d d m structures (not inclusive)
1430            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1431            * @return the ordered range of matching d d m structures that the user has permission to view
1432            * @throws SystemException if a system exception occurred
1433            */
1434            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_C(
1435                    long groupId, long classNameId, int start, int end,
1436                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1437                    throws com.liferay.portal.kernel.exception.SystemException {
1438                    return getPersistence()
1439                                       .filterFindByG_C(groupId, classNameId, start, end,
1440                            orderByComparator);
1441            }
1442    
1443            /**
1444            * Returns the d d m structures before and after the current d d m structure in the ordered set of d d m structures that the user has permission to view where groupId = &#63; and classNameId = &#63;.
1445            *
1446            * @param structureId the primary key of the current d d m structure
1447            * @param groupId the group ID
1448            * @param classNameId the class name ID
1449            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1450            * @return the previous, current, and next d d m structure
1451            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
1452            * @throws SystemException if a system exception occurred
1453            */
1454            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] filterFindByG_C_PrevAndNext(
1455                    long structureId, long groupId, long classNameId,
1456                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1457                    throws com.liferay.portal.kernel.exception.SystemException,
1458                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1459                    return getPersistence()
1460                                       .filterFindByG_C_PrevAndNext(structureId, groupId,
1461                            classNameId, orderByComparator);
1462            }
1463    
1464            /**
1465            * Removes all the d d m structures where groupId = &#63; and classNameId = &#63; from the database.
1466            *
1467            * @param groupId the group ID
1468            * @param classNameId the class name ID
1469            * @throws SystemException if a system exception occurred
1470            */
1471            public static void removeByG_C(long groupId, long classNameId)
1472                    throws com.liferay.portal.kernel.exception.SystemException {
1473                    getPersistence().removeByG_C(groupId, classNameId);
1474            }
1475    
1476            /**
1477            * Returns the number of d d m structures where groupId = &#63; and classNameId = &#63;.
1478            *
1479            * @param groupId the group ID
1480            * @param classNameId the class name ID
1481            * @return the number of matching d d m structures
1482            * @throws SystemException if a system exception occurred
1483            */
1484            public static int countByG_C(long groupId, long classNameId)
1485                    throws com.liferay.portal.kernel.exception.SystemException {
1486                    return getPersistence().countByG_C(groupId, classNameId);
1487            }
1488    
1489            /**
1490            * Returns the number of d d m structures that the user has permission to view where groupId = &#63; and classNameId = &#63;.
1491            *
1492            * @param groupId the group ID
1493            * @param classNameId the class name ID
1494            * @return the number of matching d d m structures that the user has permission to view
1495            * @throws SystemException if a system exception occurred
1496            */
1497            public static int filterCountByG_C(long groupId, long classNameId)
1498                    throws com.liferay.portal.kernel.exception.SystemException {
1499                    return getPersistence().filterCountByG_C(groupId, classNameId);
1500            }
1501    
1502            /**
1503            * Returns all the d d m structures where companyId = &#63; and classNameId = &#63;.
1504            *
1505            * @param companyId the company ID
1506            * @param classNameId the class name ID
1507            * @return the matching d d m structures
1508            * @throws SystemException if a system exception occurred
1509            */
1510            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByC_C(
1511                    long companyId, long classNameId)
1512                    throws com.liferay.portal.kernel.exception.SystemException {
1513                    return getPersistence().findByC_C(companyId, classNameId);
1514            }
1515    
1516            /**
1517            * Returns a range of all the d d m structures where companyId = &#63; and classNameId = &#63;.
1518            *
1519            * <p>
1520            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
1521            * </p>
1522            *
1523            * @param companyId the company ID
1524            * @param classNameId the class name ID
1525            * @param start the lower bound of the range of d d m structures
1526            * @param end the upper bound of the range of d d m structures (not inclusive)
1527            * @return the range of matching d d m structures
1528            * @throws SystemException if a system exception occurred
1529            */
1530            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByC_C(
1531                    long companyId, long classNameId, int start, int end)
1532                    throws com.liferay.portal.kernel.exception.SystemException {
1533                    return getPersistence().findByC_C(companyId, classNameId, start, end);
1534            }
1535    
1536            /**
1537            * Returns an ordered range of all the d d m structures where companyId = &#63; and classNameId = &#63;.
1538            *
1539            * <p>
1540            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
1541            * </p>
1542            *
1543            * @param companyId the company ID
1544            * @param classNameId the class name ID
1545            * @param start the lower bound of the range of d d m structures
1546            * @param end the upper bound of the range of d d m structures (not inclusive)
1547            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1548            * @return the ordered range of matching d d m structures
1549            * @throws SystemException if a system exception occurred
1550            */
1551            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByC_C(
1552                    long companyId, long classNameId, int start, int end,
1553                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1554                    throws com.liferay.portal.kernel.exception.SystemException {
1555                    return getPersistence()
1556                                       .findByC_C(companyId, classNameId, start, end,
1557                            orderByComparator);
1558            }
1559    
1560            /**
1561            * Returns the first d d m structure in the ordered set where companyId = &#63; and classNameId = &#63;.
1562            *
1563            * @param companyId the company ID
1564            * @param classNameId the class name ID
1565            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1566            * @return the first matching d d m structure
1567            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
1568            * @throws SystemException if a system exception occurred
1569            */
1570            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByC_C_First(
1571                    long companyId, long classNameId,
1572                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1573                    throws com.liferay.portal.kernel.exception.SystemException,
1574                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1575                    return getPersistence()
1576                                       .findByC_C_First(companyId, classNameId, orderByComparator);
1577            }
1578    
1579            /**
1580            * Returns the first d d m structure in the ordered set where companyId = &#63; and classNameId = &#63;.
1581            *
1582            * @param companyId the company ID
1583            * @param classNameId the class name ID
1584            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1585            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1586            * @throws SystemException if a system exception occurred
1587            */
1588            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByC_C_First(
1589                    long companyId, long classNameId,
1590                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1591                    throws com.liferay.portal.kernel.exception.SystemException {
1592                    return getPersistence()
1593                                       .fetchByC_C_First(companyId, classNameId, orderByComparator);
1594            }
1595    
1596            /**
1597            * Returns the last d d m structure in the ordered set where companyId = &#63; and classNameId = &#63;.
1598            *
1599            * @param companyId the company ID
1600            * @param classNameId the class name ID
1601            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1602            * @return the last matching d d m structure
1603            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
1604            * @throws SystemException if a system exception occurred
1605            */
1606            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByC_C_Last(
1607                    long companyId, long classNameId,
1608                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1609                    throws com.liferay.portal.kernel.exception.SystemException,
1610                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1611                    return getPersistence()
1612                                       .findByC_C_Last(companyId, classNameId, orderByComparator);
1613            }
1614    
1615            /**
1616            * Returns the last d d m structure in the ordered set where companyId = &#63; and classNameId = &#63;.
1617            *
1618            * @param companyId the company ID
1619            * @param classNameId the class name ID
1620            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1621            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1622            * @throws SystemException if a system exception occurred
1623            */
1624            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByC_C_Last(
1625                    long companyId, long classNameId,
1626                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1627                    throws com.liferay.portal.kernel.exception.SystemException {
1628                    return getPersistence()
1629                                       .fetchByC_C_Last(companyId, classNameId, orderByComparator);
1630            }
1631    
1632            /**
1633            * Returns the d d m structures before and after the current d d m structure in the ordered set where companyId = &#63; and classNameId = &#63;.
1634            *
1635            * @param structureId the primary key of the current d d m structure
1636            * @param companyId the company ID
1637            * @param classNameId the class name ID
1638            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1639            * @return the previous, current, and next d d m structure
1640            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
1641            * @throws SystemException if a system exception occurred
1642            */
1643            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByC_C_PrevAndNext(
1644                    long structureId, long companyId, long classNameId,
1645                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1646                    throws com.liferay.portal.kernel.exception.SystemException,
1647                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1648                    return getPersistence()
1649                                       .findByC_C_PrevAndNext(structureId, companyId, classNameId,
1650                            orderByComparator);
1651            }
1652    
1653            /**
1654            * Removes all the d d m structures where companyId = &#63; and classNameId = &#63; from the database.
1655            *
1656            * @param companyId the company ID
1657            * @param classNameId the class name ID
1658            * @throws SystemException if a system exception occurred
1659            */
1660            public static void removeByC_C(long companyId, long classNameId)
1661                    throws com.liferay.portal.kernel.exception.SystemException {
1662                    getPersistence().removeByC_C(companyId, classNameId);
1663            }
1664    
1665            /**
1666            * Returns the number of d d m structures where companyId = &#63; and classNameId = &#63;.
1667            *
1668            * @param companyId the company ID
1669            * @param classNameId the class name ID
1670            * @return the number of matching d d m structures
1671            * @throws SystemException if a system exception occurred
1672            */
1673            public static int countByC_C(long companyId, long classNameId)
1674                    throws com.liferay.portal.kernel.exception.SystemException {
1675                    return getPersistence().countByC_C(companyId, classNameId);
1676            }
1677    
1678            /**
1679            * Returns the d d m structure where groupId = &#63; and classNameId = &#63; and structureKey = &#63; or throws a {@link com.liferay.portlet.dynamicdatamapping.NoSuchStructureException} if it could not be found.
1680            *
1681            * @param groupId the group ID
1682            * @param classNameId the class name ID
1683            * @param structureKey the structure key
1684            * @return the matching d d m structure
1685            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
1686            * @throws SystemException if a system exception occurred
1687            */
1688            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByG_C_S(
1689                    long groupId, long classNameId, java.lang.String structureKey)
1690                    throws com.liferay.portal.kernel.exception.SystemException,
1691                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1692                    return getPersistence().findByG_C_S(groupId, classNameId, structureKey);
1693            }
1694    
1695            /**
1696            * Returns the d d m structure where groupId = &#63; and classNameId = &#63; and structureKey = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1697            *
1698            * @param groupId the group ID
1699            * @param classNameId the class name ID
1700            * @param structureKey the structure key
1701            * @return the matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1702            * @throws SystemException if a system exception occurred
1703            */
1704            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_C_S(
1705                    long groupId, long classNameId, java.lang.String structureKey)
1706                    throws com.liferay.portal.kernel.exception.SystemException {
1707                    return getPersistence().fetchByG_C_S(groupId, classNameId, structureKey);
1708            }
1709    
1710            /**
1711            * Returns the d d m structure where groupId = &#63; and classNameId = &#63; and structureKey = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1712            *
1713            * @param groupId the group ID
1714            * @param classNameId the class name ID
1715            * @param structureKey the structure key
1716            * @param retrieveFromCache whether to use the finder cache
1717            * @return the matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1718            * @throws SystemException if a system exception occurred
1719            */
1720            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_C_S(
1721                    long groupId, long classNameId, java.lang.String structureKey,
1722                    boolean retrieveFromCache)
1723                    throws com.liferay.portal.kernel.exception.SystemException {
1724                    return getPersistence()
1725                                       .fetchByG_C_S(groupId, classNameId, structureKey,
1726                            retrieveFromCache);
1727            }
1728    
1729            /**
1730            * Removes the d d m structure where groupId = &#63; and classNameId = &#63; and structureKey = &#63; from the database.
1731            *
1732            * @param groupId the group ID
1733            * @param classNameId the class name ID
1734            * @param structureKey the structure key
1735            * @return the d d m structure that was removed
1736            * @throws SystemException if a system exception occurred
1737            */
1738            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure removeByG_C_S(
1739                    long groupId, long classNameId, java.lang.String structureKey)
1740                    throws com.liferay.portal.kernel.exception.SystemException,
1741                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1742                    return getPersistence().removeByG_C_S(groupId, classNameId, structureKey);
1743            }
1744    
1745            /**
1746            * Returns the number of d d m structures where groupId = &#63; and classNameId = &#63; and structureKey = &#63;.
1747            *
1748            * @param groupId the group ID
1749            * @param classNameId the class name ID
1750            * @param structureKey the structure key
1751            * @return the number of matching d d m structures
1752            * @throws SystemException if a system exception occurred
1753            */
1754            public static int countByG_C_S(long groupId, long classNameId,
1755                    java.lang.String structureKey)
1756                    throws com.liferay.portal.kernel.exception.SystemException {
1757                    return getPersistence().countByG_C_S(groupId, classNameId, structureKey);
1758            }
1759    
1760            /**
1761            * Returns all the d d m structures where groupId = &#63; and name = &#63; and description = &#63;.
1762            *
1763            * @param groupId the group ID
1764            * @param name the name
1765            * @param description the description
1766            * @return the matching d d m structures
1767            * @throws SystemException if a system exception occurred
1768            */
1769            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_N_D(
1770                    long groupId, java.lang.String name, java.lang.String description)
1771                    throws com.liferay.portal.kernel.exception.SystemException {
1772                    return getPersistence().findByG_N_D(groupId, name, description);
1773            }
1774    
1775            /**
1776            * Returns a range of all the d d m structures where groupId = &#63; and name = &#63; and description = &#63;.
1777            *
1778            * <p>
1779            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
1780            * </p>
1781            *
1782            * @param groupId the group ID
1783            * @param name the name
1784            * @param description the description
1785            * @param start the lower bound of the range of d d m structures
1786            * @param end the upper bound of the range of d d m structures (not inclusive)
1787            * @return the range of matching d d m structures
1788            * @throws SystemException if a system exception occurred
1789            */
1790            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_N_D(
1791                    long groupId, java.lang.String name, java.lang.String description,
1792                    int start, int end)
1793                    throws com.liferay.portal.kernel.exception.SystemException {
1794                    return getPersistence()
1795                                       .findByG_N_D(groupId, name, description, start, end);
1796            }
1797    
1798            /**
1799            * Returns an ordered range of all the d d m structures where groupId = &#63; and name = &#63; and description = &#63;.
1800            *
1801            * <p>
1802            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
1803            * </p>
1804            *
1805            * @param groupId the group ID
1806            * @param name the name
1807            * @param description the description
1808            * @param start the lower bound of the range of d d m structures
1809            * @param end the upper bound of the range of d d m structures (not inclusive)
1810            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1811            * @return the ordered range of matching d d m structures
1812            * @throws SystemException if a system exception occurred
1813            */
1814            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_N_D(
1815                    long groupId, java.lang.String name, java.lang.String description,
1816                    int start, int end,
1817                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1818                    throws com.liferay.portal.kernel.exception.SystemException {
1819                    return getPersistence()
1820                                       .findByG_N_D(groupId, name, description, start, end,
1821                            orderByComparator);
1822            }
1823    
1824            /**
1825            * Returns the first d d m structure in the ordered set where groupId = &#63; and name = &#63; and description = &#63;.
1826            *
1827            * @param groupId the group ID
1828            * @param name the name
1829            * @param description the description
1830            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1831            * @return the first matching d d m structure
1832            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
1833            * @throws SystemException if a system exception occurred
1834            */
1835            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByG_N_D_First(
1836                    long groupId, java.lang.String name, java.lang.String description,
1837                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1838                    throws com.liferay.portal.kernel.exception.SystemException,
1839                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1840                    return getPersistence()
1841                                       .findByG_N_D_First(groupId, name, description,
1842                            orderByComparator);
1843            }
1844    
1845            /**
1846            * Returns the first d d m structure in the ordered set where groupId = &#63; and name = &#63; and description = &#63;.
1847            *
1848            * @param groupId the group ID
1849            * @param name the name
1850            * @param description the description
1851            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1852            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1853            * @throws SystemException if a system exception occurred
1854            */
1855            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_N_D_First(
1856                    long groupId, java.lang.String name, java.lang.String description,
1857                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1858                    throws com.liferay.portal.kernel.exception.SystemException {
1859                    return getPersistence()
1860                                       .fetchByG_N_D_First(groupId, name, description,
1861                            orderByComparator);
1862            }
1863    
1864            /**
1865            * Returns the last d d m structure in the ordered set where groupId = &#63; and name = &#63; and description = &#63;.
1866            *
1867            * @param groupId the group ID
1868            * @param name the name
1869            * @param description the description
1870            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1871            * @return the last matching d d m structure
1872            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
1873            * @throws SystemException if a system exception occurred
1874            */
1875            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByG_N_D_Last(
1876                    long groupId, java.lang.String name, java.lang.String description,
1877                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1878                    throws com.liferay.portal.kernel.exception.SystemException,
1879                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1880                    return getPersistence()
1881                                       .findByG_N_D_Last(groupId, name, description,
1882                            orderByComparator);
1883            }
1884    
1885            /**
1886            * Returns the last d d m structure in the ordered set where groupId = &#63; and name = &#63; and description = &#63;.
1887            *
1888            * @param groupId the group ID
1889            * @param name the name
1890            * @param description the description
1891            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1892            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1893            * @throws SystemException if a system exception occurred
1894            */
1895            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_N_D_Last(
1896                    long groupId, java.lang.String name, java.lang.String description,
1897                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1898                    throws com.liferay.portal.kernel.exception.SystemException {
1899                    return getPersistence()
1900                                       .fetchByG_N_D_Last(groupId, name, description,
1901                            orderByComparator);
1902            }
1903    
1904            /**
1905            * Returns the d d m structures before and after the current d d m structure in the ordered set where groupId = &#63; and name = &#63; and description = &#63;.
1906            *
1907            * @param structureId the primary key of the current d d m structure
1908            * @param groupId the group ID
1909            * @param name the name
1910            * @param description the description
1911            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1912            * @return the previous, current, and next d d m structure
1913            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
1914            * @throws SystemException if a system exception occurred
1915            */
1916            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByG_N_D_PrevAndNext(
1917                    long structureId, long groupId, java.lang.String name,
1918                    java.lang.String description,
1919                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1920                    throws com.liferay.portal.kernel.exception.SystemException,
1921                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1922                    return getPersistence()
1923                                       .findByG_N_D_PrevAndNext(structureId, groupId, name,
1924                            description, orderByComparator);
1925            }
1926    
1927            /**
1928            * Returns all the d d m structures that the user has permission to view where groupId = &#63; and name = &#63; and description = &#63;.
1929            *
1930            * @param groupId the group ID
1931            * @param name the name
1932            * @param description the description
1933            * @return the matching d d m structures that the user has permission to view
1934            * @throws SystemException if a system exception occurred
1935            */
1936            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_N_D(
1937                    long groupId, java.lang.String name, java.lang.String description)
1938                    throws com.liferay.portal.kernel.exception.SystemException {
1939                    return getPersistence().filterFindByG_N_D(groupId, name, description);
1940            }
1941    
1942            /**
1943            * Returns a range of all the d d m structures that the user has permission to view where groupId = &#63; and name = &#63; and description = &#63;.
1944            *
1945            * <p>
1946            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
1947            * </p>
1948            *
1949            * @param groupId the group ID
1950            * @param name the name
1951            * @param description the description
1952            * @param start the lower bound of the range of d d m structures
1953            * @param end the upper bound of the range of d d m structures (not inclusive)
1954            * @return the range of matching d d m structures that the user has permission to view
1955            * @throws SystemException if a system exception occurred
1956            */
1957            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_N_D(
1958                    long groupId, java.lang.String name, java.lang.String description,
1959                    int start, int end)
1960                    throws com.liferay.portal.kernel.exception.SystemException {
1961                    return getPersistence()
1962                                       .filterFindByG_N_D(groupId, name, description, start, end);
1963            }
1964    
1965            /**
1966            * Returns an ordered range of all the d d m structures that the user has permissions to view where groupId = &#63; and name = &#63; and description = &#63;.
1967            *
1968            * <p>
1969            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
1970            * </p>
1971            *
1972            * @param groupId the group ID
1973            * @param name the name
1974            * @param description the description
1975            * @param start the lower bound of the range of d d m structures
1976            * @param end the upper bound of the range of d d m structures (not inclusive)
1977            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1978            * @return the ordered range of matching d d m structures that the user has permission to view
1979            * @throws SystemException if a system exception occurred
1980            */
1981            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_N_D(
1982                    long groupId, java.lang.String name, java.lang.String description,
1983                    int start, int end,
1984                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1985                    throws com.liferay.portal.kernel.exception.SystemException {
1986                    return getPersistence()
1987                                       .filterFindByG_N_D(groupId, name, description, start, end,
1988                            orderByComparator);
1989            }
1990    
1991            /**
1992            * Returns the d d m structures before and after the current d d m structure in the ordered set of d d m structures that the user has permission to view where groupId = &#63; and name = &#63; and description = &#63;.
1993            *
1994            * @param structureId the primary key of the current d d m structure
1995            * @param groupId the group ID
1996            * @param name the name
1997            * @param description the description
1998            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1999            * @return the previous, current, and next d d m structure
2000            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
2001            * @throws SystemException if a system exception occurred
2002            */
2003            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] filterFindByG_N_D_PrevAndNext(
2004                    long structureId, long groupId, java.lang.String name,
2005                    java.lang.String description,
2006                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2007                    throws com.liferay.portal.kernel.exception.SystemException,
2008                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
2009                    return getPersistence()
2010                                       .filterFindByG_N_D_PrevAndNext(structureId, groupId, name,
2011                            description, orderByComparator);
2012            }
2013    
2014            /**
2015            * Removes all the d d m structures where groupId = &#63; and name = &#63; and description = &#63; from the database.
2016            *
2017            * @param groupId the group ID
2018            * @param name the name
2019            * @param description the description
2020            * @throws SystemException if a system exception occurred
2021            */
2022            public static void removeByG_N_D(long groupId, java.lang.String name,
2023                    java.lang.String description)
2024                    throws com.liferay.portal.kernel.exception.SystemException {
2025                    getPersistence().removeByG_N_D(groupId, name, description);
2026            }
2027    
2028            /**
2029            * Returns the number of d d m structures where groupId = &#63; and name = &#63; and description = &#63;.
2030            *
2031            * @param groupId the group ID
2032            * @param name the name
2033            * @param description the description
2034            * @return the number of matching d d m structures
2035            * @throws SystemException if a system exception occurred
2036            */
2037            public static int countByG_N_D(long groupId, java.lang.String name,
2038                    java.lang.String description)
2039                    throws com.liferay.portal.kernel.exception.SystemException {
2040                    return getPersistence().countByG_N_D(groupId, name, description);
2041            }
2042    
2043            /**
2044            * Returns the number of d d m structures that the user has permission to view where groupId = &#63; and name = &#63; and description = &#63;.
2045            *
2046            * @param groupId the group ID
2047            * @param name the name
2048            * @param description the description
2049            * @return the number of matching d d m structures that the user has permission to view
2050            * @throws SystemException if a system exception occurred
2051            */
2052            public static int filterCountByG_N_D(long groupId, java.lang.String name,
2053                    java.lang.String description)
2054                    throws com.liferay.portal.kernel.exception.SystemException {
2055                    return getPersistence().filterCountByG_N_D(groupId, name, description);
2056            }
2057    
2058            /**
2059            * Caches the d d m structure in the entity cache if it is enabled.
2060            *
2061            * @param ddmStructure the d d m structure
2062            */
2063            public static void cacheResult(
2064                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure) {
2065                    getPersistence().cacheResult(ddmStructure);
2066            }
2067    
2068            /**
2069            * Caches the d d m structures in the entity cache if it is enabled.
2070            *
2071            * @param ddmStructures the d d m structures
2072            */
2073            public static void cacheResult(
2074                    java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> ddmStructures) {
2075                    getPersistence().cacheResult(ddmStructures);
2076            }
2077    
2078            /**
2079            * Creates a new d d m structure with the primary key. Does not add the d d m structure to the database.
2080            *
2081            * @param structureId the primary key for the new d d m structure
2082            * @return the new d d m structure
2083            */
2084            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure create(
2085                    long structureId) {
2086                    return getPersistence().create(structureId);
2087            }
2088    
2089            /**
2090            * Removes the d d m structure with the primary key from the database. Also notifies the appropriate model listeners.
2091            *
2092            * @param structureId the primary key of the d d m structure
2093            * @return the d d m structure that was removed
2094            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
2095            * @throws SystemException if a system exception occurred
2096            */
2097            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure remove(
2098                    long structureId)
2099                    throws com.liferay.portal.kernel.exception.SystemException,
2100                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
2101                    return getPersistence().remove(structureId);
2102            }
2103    
2104            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure updateImpl(
2105                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure)
2106                    throws com.liferay.portal.kernel.exception.SystemException {
2107                    return getPersistence().updateImpl(ddmStructure);
2108            }
2109    
2110            /**
2111            * Returns the d d m structure with the primary key or throws a {@link com.liferay.portlet.dynamicdatamapping.NoSuchStructureException} if it could not be found.
2112            *
2113            * @param structureId the primary key of the d d m structure
2114            * @return the d d m structure
2115            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
2116            * @throws SystemException if a system exception occurred
2117            */
2118            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByPrimaryKey(
2119                    long structureId)
2120                    throws com.liferay.portal.kernel.exception.SystemException,
2121                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
2122                    return getPersistence().findByPrimaryKey(structureId);
2123            }
2124    
2125            /**
2126            * Returns the d d m structure with the primary key or returns <code>null</code> if it could not be found.
2127            *
2128            * @param structureId the primary key of the d d m structure
2129            * @return the d d m structure, or <code>null</code> if a d d m structure with the primary key could not be found
2130            * @throws SystemException if a system exception occurred
2131            */
2132            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByPrimaryKey(
2133                    long structureId)
2134                    throws com.liferay.portal.kernel.exception.SystemException {
2135                    return getPersistence().fetchByPrimaryKey(structureId);
2136            }
2137    
2138            /**
2139            * Returns all the d d m structures.
2140            *
2141            * @return the d d m structures
2142            * @throws SystemException if a system exception occurred
2143            */
2144            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findAll()
2145                    throws com.liferay.portal.kernel.exception.SystemException {
2146                    return getPersistence().findAll();
2147            }
2148    
2149            /**
2150            * Returns a range of all the d d m structures.
2151            *
2152            * <p>
2153            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
2154            * </p>
2155            *
2156            * @param start the lower bound of the range of d d m structures
2157            * @param end the upper bound of the range of d d m structures (not inclusive)
2158            * @return the range of d d m structures
2159            * @throws SystemException if a system exception occurred
2160            */
2161            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findAll(
2162                    int start, int end)
2163                    throws com.liferay.portal.kernel.exception.SystemException {
2164                    return getPersistence().findAll(start, end);
2165            }
2166    
2167            /**
2168            * Returns an ordered range of all the d d m structures.
2169            *
2170            * <p>
2171            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
2172            * </p>
2173            *
2174            * @param start the lower bound of the range of d d m structures
2175            * @param end the upper bound of the range of d d m structures (not inclusive)
2176            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2177            * @return the ordered range of d d m structures
2178            * @throws SystemException if a system exception occurred
2179            */
2180            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findAll(
2181                    int start, int end,
2182                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2183                    throws com.liferay.portal.kernel.exception.SystemException {
2184                    return getPersistence().findAll(start, end, orderByComparator);
2185            }
2186    
2187            /**
2188            * Removes all the d d m structures from the database.
2189            *
2190            * @throws SystemException if a system exception occurred
2191            */
2192            public static void removeAll()
2193                    throws com.liferay.portal.kernel.exception.SystemException {
2194                    getPersistence().removeAll();
2195            }
2196    
2197            /**
2198            * Returns the number of d d m structures.
2199            *
2200            * @return the number of d d m structures
2201            * @throws SystemException if a system exception occurred
2202            */
2203            public static int countAll()
2204                    throws com.liferay.portal.kernel.exception.SystemException {
2205                    return getPersistence().countAll();
2206            }
2207    
2208            public static DDMStructurePersistence getPersistence() {
2209                    if (_persistence == null) {
2210                            _persistence = (DDMStructurePersistence)PortalBeanLocatorUtil.locate(DDMStructurePersistence.class.getName());
2211    
2212                            ReferenceRegistry.registerReference(DDMStructureUtil.class,
2213                                    "_persistence");
2214                    }
2215    
2216                    return _persistence;
2217            }
2218    
2219            /**
2220             * @deprecated
2221             */
2222            public void setPersistence(DDMStructurePersistence persistence) {
2223            }
2224    
2225            private static DDMStructurePersistence _persistence;
2226    }