001    /**
002     * Copyright (c) 2000-2013 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 parentStructureId = &#63;.
1236            *
1237            * @param groupId the group ID
1238            * @param parentStructureId the parent structure 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_P(
1243                    long groupId, long parentStructureId)
1244                    throws com.liferay.portal.kernel.exception.SystemException {
1245                    return getPersistence().findByG_P(groupId, parentStructureId);
1246            }
1247    
1248            /**
1249            * Returns a range of all the d d m structures where groupId = &#63; and parentStructureId = &#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 parentStructureId the parent structure 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_P(
1263                    long groupId, long parentStructureId, int start, int end)
1264                    throws com.liferay.portal.kernel.exception.SystemException {
1265                    return getPersistence().findByG_P(groupId, parentStructureId, start, end);
1266            }
1267    
1268            /**
1269            * Returns an ordered range of all the d d m structures where groupId = &#63; and parentStructureId = &#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 parentStructureId the parent structure 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_P(
1284                    long groupId, long parentStructureId, 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_P(groupId, parentStructureId, start, end,
1289                            orderByComparator);
1290            }
1291    
1292            /**
1293            * Returns the first d d m structure in the ordered set where groupId = &#63; and parentStructureId = &#63;.
1294            *
1295            * @param groupId the group ID
1296            * @param parentStructureId the parent structure 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_P_First(
1303                    long groupId, long parentStructureId,
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_P_First(groupId, parentStructureId,
1309                            orderByComparator);
1310            }
1311    
1312            /**
1313            * Returns the first d d m structure in the ordered set where groupId = &#63; and parentStructureId = &#63;.
1314            *
1315            * @param groupId the group ID
1316            * @param parentStructureId the parent structure ID
1317            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1318            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1319            * @throws SystemException if a system exception occurred
1320            */
1321            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_P_First(
1322                    long groupId, long parentStructureId,
1323                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1324                    throws com.liferay.portal.kernel.exception.SystemException {
1325                    return getPersistence()
1326                                       .fetchByG_P_First(groupId, parentStructureId,
1327                            orderByComparator);
1328            }
1329    
1330            /**
1331            * Returns the last d d m structure in the ordered set where groupId = &#63; and parentStructureId = &#63;.
1332            *
1333            * @param groupId the group ID
1334            * @param parentStructureId the parent structure ID
1335            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1336            * @return the last matching d d m structure
1337            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
1338            * @throws SystemException if a system exception occurred
1339            */
1340            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByG_P_Last(
1341                    long groupId, long parentStructureId,
1342                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1343                    throws com.liferay.portal.kernel.exception.SystemException,
1344                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1345                    return getPersistence()
1346                                       .findByG_P_Last(groupId, parentStructureId, orderByComparator);
1347            }
1348    
1349            /**
1350            * Returns the last d d m structure in the ordered set where groupId = &#63; and parentStructureId = &#63;.
1351            *
1352            * @param groupId the group ID
1353            * @param parentStructureId the parent structure ID
1354            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1355            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1356            * @throws SystemException if a system exception occurred
1357            */
1358            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_P_Last(
1359                    long groupId, long parentStructureId,
1360                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1361                    throws com.liferay.portal.kernel.exception.SystemException {
1362                    return getPersistence()
1363                                       .fetchByG_P_Last(groupId, parentStructureId,
1364                            orderByComparator);
1365            }
1366    
1367            /**
1368            * Returns the d d m structures before and after the current d d m structure in the ordered set where groupId = &#63; and parentStructureId = &#63;.
1369            *
1370            * @param structureId the primary key of the current d d m structure
1371            * @param groupId the group ID
1372            * @param parentStructureId the parent structure ID
1373            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1374            * @return the previous, current, and next d d m structure
1375            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
1376            * @throws SystemException if a system exception occurred
1377            */
1378            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByG_P_PrevAndNext(
1379                    long structureId, long groupId, long parentStructureId,
1380                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1381                    throws com.liferay.portal.kernel.exception.SystemException,
1382                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1383                    return getPersistence()
1384                                       .findByG_P_PrevAndNext(structureId, groupId,
1385                            parentStructureId, orderByComparator);
1386            }
1387    
1388            /**
1389            * Returns all the d d m structures that the user has permission to view where groupId = &#63; and parentStructureId = &#63;.
1390            *
1391            * @param groupId the group ID
1392            * @param parentStructureId the parent structure ID
1393            * @return the matching d d m structures that the user has permission to view
1394            * @throws SystemException if a system exception occurred
1395            */
1396            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_P(
1397                    long groupId, long parentStructureId)
1398                    throws com.liferay.portal.kernel.exception.SystemException {
1399                    return getPersistence().filterFindByG_P(groupId, parentStructureId);
1400            }
1401    
1402            /**
1403            * Returns a range of all the d d m structures that the user has permission to view where groupId = &#63; and parentStructureId = &#63;.
1404            *
1405            * <p>
1406            * 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.
1407            * </p>
1408            *
1409            * @param groupId the group ID
1410            * @param parentStructureId the parent structure ID
1411            * @param start the lower bound of the range of d d m structures
1412            * @param end the upper bound of the range of d d m structures (not inclusive)
1413            * @return the range of matching d d m structures that the user has permission to view
1414            * @throws SystemException if a system exception occurred
1415            */
1416            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_P(
1417                    long groupId, long parentStructureId, int start, int end)
1418                    throws com.liferay.portal.kernel.exception.SystemException {
1419                    return getPersistence()
1420                                       .filterFindByG_P(groupId, parentStructureId, start, end);
1421            }
1422    
1423            /**
1424            * Returns an ordered range of all the d d m structures that the user has permissions to view where groupId = &#63; and parentStructureId = &#63;.
1425            *
1426            * <p>
1427            * 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.
1428            * </p>
1429            *
1430            * @param groupId the group ID
1431            * @param parentStructureId the parent structure ID
1432            * @param start the lower bound of the range of d d m structures
1433            * @param end the upper bound of the range of d d m structures (not inclusive)
1434            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1435            * @return the ordered range of matching d d m structures that the user has permission to view
1436            * @throws SystemException if a system exception occurred
1437            */
1438            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_P(
1439                    long groupId, long parentStructureId, int start, int end,
1440                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1441                    throws com.liferay.portal.kernel.exception.SystemException {
1442                    return getPersistence()
1443                                       .filterFindByG_P(groupId, parentStructureId, start, end,
1444                            orderByComparator);
1445            }
1446    
1447            /**
1448            * 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 parentStructureId = &#63;.
1449            *
1450            * @param structureId the primary key of the current d d m structure
1451            * @param groupId the group ID
1452            * @param parentStructureId the parent structure ID
1453            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1454            * @return the previous, current, and next d d m structure
1455            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
1456            * @throws SystemException if a system exception occurred
1457            */
1458            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] filterFindByG_P_PrevAndNext(
1459                    long structureId, long groupId, long parentStructureId,
1460                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1461                    throws com.liferay.portal.kernel.exception.SystemException,
1462                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1463                    return getPersistence()
1464                                       .filterFindByG_P_PrevAndNext(structureId, groupId,
1465                            parentStructureId, orderByComparator);
1466            }
1467    
1468            /**
1469            * Removes all the d d m structures where groupId = &#63; and parentStructureId = &#63; from the database.
1470            *
1471            * @param groupId the group ID
1472            * @param parentStructureId the parent structure ID
1473            * @throws SystemException if a system exception occurred
1474            */
1475            public static void removeByG_P(long groupId, long parentStructureId)
1476                    throws com.liferay.portal.kernel.exception.SystemException {
1477                    getPersistence().removeByG_P(groupId, parentStructureId);
1478            }
1479    
1480            /**
1481            * Returns the number of d d m structures where groupId = &#63; and parentStructureId = &#63;.
1482            *
1483            * @param groupId the group ID
1484            * @param parentStructureId the parent structure ID
1485            * @return the number of matching d d m structures
1486            * @throws SystemException if a system exception occurred
1487            */
1488            public static int countByG_P(long groupId, long parentStructureId)
1489                    throws com.liferay.portal.kernel.exception.SystemException {
1490                    return getPersistence().countByG_P(groupId, parentStructureId);
1491            }
1492    
1493            /**
1494            * Returns the number of d d m structures that the user has permission to view where groupId = &#63; and parentStructureId = &#63;.
1495            *
1496            * @param groupId the group ID
1497            * @param parentStructureId the parent structure ID
1498            * @return the number of matching d d m structures that the user has permission to view
1499            * @throws SystemException if a system exception occurred
1500            */
1501            public static int filterCountByG_P(long groupId, long parentStructureId)
1502                    throws com.liferay.portal.kernel.exception.SystemException {
1503                    return getPersistence().filterCountByG_P(groupId, parentStructureId);
1504            }
1505    
1506            /**
1507            * Returns all the d d m structures where groupId = &#63; and classNameId = &#63;.
1508            *
1509            * @param groupId the group ID
1510            * @param classNameId the class name ID
1511            * @return the matching d d m structures
1512            * @throws SystemException if a system exception occurred
1513            */
1514            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_C(
1515                    long groupId, long classNameId)
1516                    throws com.liferay.portal.kernel.exception.SystemException {
1517                    return getPersistence().findByG_C(groupId, classNameId);
1518            }
1519    
1520            /**
1521            * Returns a range of all the d d m structures where groupId = &#63; and classNameId = &#63;.
1522            *
1523            * <p>
1524            * 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.
1525            * </p>
1526            *
1527            * @param groupId the group ID
1528            * @param classNameId the class name ID
1529            * @param start the lower bound of the range of d d m structures
1530            * @param end the upper bound of the range of d d m structures (not inclusive)
1531            * @return the range of matching d d m structures
1532            * @throws SystemException if a system exception occurred
1533            */
1534            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_C(
1535                    long groupId, long classNameId, int start, int end)
1536                    throws com.liferay.portal.kernel.exception.SystemException {
1537                    return getPersistence().findByG_C(groupId, classNameId, start, end);
1538            }
1539    
1540            /**
1541            * Returns an ordered range of all the d d m structures where groupId = &#63; and classNameId = &#63;.
1542            *
1543            * <p>
1544            * 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.
1545            * </p>
1546            *
1547            * @param groupId the group ID
1548            * @param classNameId the class name ID
1549            * @param start the lower bound of the range of d d m structures
1550            * @param end the upper bound of the range of d d m structures (not inclusive)
1551            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1552            * @return the ordered range of matching d d m structures
1553            * @throws SystemException if a system exception occurred
1554            */
1555            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_C(
1556                    long groupId, long classNameId, int start, int end,
1557                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1558                    throws com.liferay.portal.kernel.exception.SystemException {
1559                    return getPersistence()
1560                                       .findByG_C(groupId, classNameId, start, end,
1561                            orderByComparator);
1562            }
1563    
1564            /**
1565            * Returns the first d d m structure in the ordered set where groupId = &#63; and classNameId = &#63;.
1566            *
1567            * @param groupId the group ID
1568            * @param classNameId the class name ID
1569            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1570            * @return the first matching d d m structure
1571            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
1572            * @throws SystemException if a system exception occurred
1573            */
1574            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByG_C_First(
1575                    long groupId, long classNameId,
1576                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1577                    throws com.liferay.portal.kernel.exception.SystemException,
1578                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1579                    return getPersistence()
1580                                       .findByG_C_First(groupId, classNameId, orderByComparator);
1581            }
1582    
1583            /**
1584            * Returns the first d d m structure in the ordered set where groupId = &#63; and classNameId = &#63;.
1585            *
1586            * @param groupId the group ID
1587            * @param classNameId the class name ID
1588            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1589            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1590            * @throws SystemException if a system exception occurred
1591            */
1592            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_C_First(
1593                    long groupId, long classNameId,
1594                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1595                    throws com.liferay.portal.kernel.exception.SystemException {
1596                    return getPersistence()
1597                                       .fetchByG_C_First(groupId, classNameId, orderByComparator);
1598            }
1599    
1600            /**
1601            * Returns the last d d m structure in the ordered set where groupId = &#63; and classNameId = &#63;.
1602            *
1603            * @param groupId the group ID
1604            * @param classNameId the class name ID
1605            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1606            * @return the last matching d d m structure
1607            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
1608            * @throws SystemException if a system exception occurred
1609            */
1610            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByG_C_Last(
1611                    long groupId, long classNameId,
1612                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1613                    throws com.liferay.portal.kernel.exception.SystemException,
1614                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1615                    return getPersistence()
1616                                       .findByG_C_Last(groupId, classNameId, orderByComparator);
1617            }
1618    
1619            /**
1620            * Returns the last d d m structure in the ordered set where groupId = &#63; and classNameId = &#63;.
1621            *
1622            * @param groupId the group ID
1623            * @param classNameId the class name ID
1624            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1625            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1626            * @throws SystemException if a system exception occurred
1627            */
1628            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_C_Last(
1629                    long groupId, long classNameId,
1630                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1631                    throws com.liferay.portal.kernel.exception.SystemException {
1632                    return getPersistence()
1633                                       .fetchByG_C_Last(groupId, classNameId, orderByComparator);
1634            }
1635    
1636            /**
1637            * 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;.
1638            *
1639            * @param structureId the primary key of the current d d m structure
1640            * @param groupId the group ID
1641            * @param classNameId the class name ID
1642            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1643            * @return the previous, current, and next d d m structure
1644            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
1645            * @throws SystemException if a system exception occurred
1646            */
1647            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByG_C_PrevAndNext(
1648                    long structureId, long groupId, long classNameId,
1649                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1650                    throws com.liferay.portal.kernel.exception.SystemException,
1651                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1652                    return getPersistence()
1653                                       .findByG_C_PrevAndNext(structureId, groupId, classNameId,
1654                            orderByComparator);
1655            }
1656    
1657            /**
1658            * Returns all the d d m structures that the user has permission to view where groupId = &#63; and classNameId = &#63;.
1659            *
1660            * @param groupId the group ID
1661            * @param classNameId the class name ID
1662            * @return the matching d d m structures that the user has permission to view
1663            * @throws SystemException if a system exception occurred
1664            */
1665            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_C(
1666                    long groupId, long classNameId)
1667                    throws com.liferay.portal.kernel.exception.SystemException {
1668                    return getPersistence().filterFindByG_C(groupId, classNameId);
1669            }
1670    
1671            /**
1672            * Returns a range of all the d d m structures that the user has permission to view where groupId = &#63; and classNameId = &#63;.
1673            *
1674            * <p>
1675            * 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.
1676            * </p>
1677            *
1678            * @param groupId the group ID
1679            * @param classNameId the class name ID
1680            * @param start the lower bound of the range of d d m structures
1681            * @param end the upper bound of the range of d d m structures (not inclusive)
1682            * @return the range of matching d d m structures that the user has permission to view
1683            * @throws SystemException if a system exception occurred
1684            */
1685            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_C(
1686                    long groupId, long classNameId, int start, int end)
1687                    throws com.liferay.portal.kernel.exception.SystemException {
1688                    return getPersistence().filterFindByG_C(groupId, classNameId, start, end);
1689            }
1690    
1691            /**
1692            * Returns an ordered range of all the d d m structures that the user has permissions to view where groupId = &#63; and classNameId = &#63;.
1693            *
1694            * <p>
1695            * 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.
1696            * </p>
1697            *
1698            * @param groupId the group ID
1699            * @param classNameId the class name ID
1700            * @param start the lower bound of the range of d d m structures
1701            * @param end the upper bound of the range of d d m structures (not inclusive)
1702            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1703            * @return the ordered range of matching d d m structures that the user has permission to view
1704            * @throws SystemException if a system exception occurred
1705            */
1706            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_C(
1707                    long groupId, long classNameId, int start, int end,
1708                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1709                    throws com.liferay.portal.kernel.exception.SystemException {
1710                    return getPersistence()
1711                                       .filterFindByG_C(groupId, classNameId, start, end,
1712                            orderByComparator);
1713            }
1714    
1715            /**
1716            * 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;.
1717            *
1718            * @param structureId the primary key of the current d d m structure
1719            * @param groupId the group ID
1720            * @param classNameId the class name ID
1721            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1722            * @return the previous, current, and next d d m structure
1723            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
1724            * @throws SystemException if a system exception occurred
1725            */
1726            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] filterFindByG_C_PrevAndNext(
1727                    long structureId, long groupId, long classNameId,
1728                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1729                    throws com.liferay.portal.kernel.exception.SystemException,
1730                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1731                    return getPersistence()
1732                                       .filterFindByG_C_PrevAndNext(structureId, groupId,
1733                            classNameId, orderByComparator);
1734            }
1735    
1736            /**
1737            * Returns all the d d m structures that the user has permission to view where groupId = any &#63; and classNameId = &#63;.
1738            *
1739            * @param groupIds the group IDs
1740            * @param classNameId the class name ID
1741            * @return the matching d d m structures that the user has permission to view
1742            * @throws SystemException if a system exception occurred
1743            */
1744            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_C(
1745                    long[] groupIds, long classNameId)
1746                    throws com.liferay.portal.kernel.exception.SystemException {
1747                    return getPersistence().filterFindByG_C(groupIds, classNameId);
1748            }
1749    
1750            /**
1751            * Returns a range of all the d d m structures that the user has permission to view where groupId = any &#63; and classNameId = &#63;.
1752            *
1753            * <p>
1754            * 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.
1755            * </p>
1756            *
1757            * @param groupIds the group IDs
1758            * @param classNameId the class name ID
1759            * @param start the lower bound of the range of d d m structures
1760            * @param end the upper bound of the range of d d m structures (not inclusive)
1761            * @return the range of matching d d m structures that the user has permission to view
1762            * @throws SystemException if a system exception occurred
1763            */
1764            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_C(
1765                    long[] groupIds, long classNameId, int start, int end)
1766                    throws com.liferay.portal.kernel.exception.SystemException {
1767                    return getPersistence()
1768                                       .filterFindByG_C(groupIds, classNameId, start, end);
1769            }
1770    
1771            /**
1772            * Returns an ordered range of all the d d m structures that the user has permission to view where groupId = any &#63; and classNameId = &#63;.
1773            *
1774            * <p>
1775            * 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.
1776            * </p>
1777            *
1778            * @param groupIds the group IDs
1779            * @param classNameId the class name ID
1780            * @param start the lower bound of the range of d d m structures
1781            * @param end the upper bound of the range of d d m structures (not inclusive)
1782            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1783            * @return the ordered range of matching d d m structures that the user has permission to view
1784            * @throws SystemException if a system exception occurred
1785            */
1786            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_C(
1787                    long[] groupIds, long classNameId, int start, int end,
1788                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1789                    throws com.liferay.portal.kernel.exception.SystemException {
1790                    return getPersistence()
1791                                       .filterFindByG_C(groupIds, classNameId, start, end,
1792                            orderByComparator);
1793            }
1794    
1795            /**
1796            * Returns all the d d m structures where groupId = any &#63; and classNameId = &#63;.
1797            *
1798            * <p>
1799            * 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.
1800            * </p>
1801            *
1802            * @param groupIds the group IDs
1803            * @param classNameId the class name ID
1804            * @return the matching d d m structures
1805            * @throws SystemException if a system exception occurred
1806            */
1807            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_C(
1808                    long[] groupIds, long classNameId)
1809                    throws com.liferay.portal.kernel.exception.SystemException {
1810                    return getPersistence().findByG_C(groupIds, classNameId);
1811            }
1812    
1813            /**
1814            * Returns a range of all the d d m structures where groupId = any &#63; and classNameId = &#63;.
1815            *
1816            * <p>
1817            * 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.
1818            * </p>
1819            *
1820            * @param groupIds the group IDs
1821            * @param classNameId the class name ID
1822            * @param start the lower bound of the range of d d m structures
1823            * @param end the upper bound of the range of d d m structures (not inclusive)
1824            * @return the range of matching d d m structures
1825            * @throws SystemException if a system exception occurred
1826            */
1827            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_C(
1828                    long[] groupIds, long classNameId, int start, int end)
1829                    throws com.liferay.portal.kernel.exception.SystemException {
1830                    return getPersistence().findByG_C(groupIds, classNameId, start, end);
1831            }
1832    
1833            /**
1834            * Returns an ordered range of all the d d m structures where groupId = any &#63; and classNameId = &#63;.
1835            *
1836            * <p>
1837            * 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.
1838            * </p>
1839            *
1840            * @param groupIds the group IDs
1841            * @param classNameId the class name ID
1842            * @param start the lower bound of the range of d d m structures
1843            * @param end the upper bound of the range of d d m structures (not inclusive)
1844            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1845            * @return the ordered range of matching d d m structures
1846            * @throws SystemException if a system exception occurred
1847            */
1848            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_C(
1849                    long[] groupIds, long classNameId, int start, int end,
1850                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1851                    throws com.liferay.portal.kernel.exception.SystemException {
1852                    return getPersistence()
1853                                       .findByG_C(groupIds, classNameId, start, end,
1854                            orderByComparator);
1855            }
1856    
1857            /**
1858            * Removes all the d d m structures where groupId = &#63; and classNameId = &#63; from the database.
1859            *
1860            * @param groupId the group ID
1861            * @param classNameId the class name ID
1862            * @throws SystemException if a system exception occurred
1863            */
1864            public static void removeByG_C(long groupId, long classNameId)
1865                    throws com.liferay.portal.kernel.exception.SystemException {
1866                    getPersistence().removeByG_C(groupId, classNameId);
1867            }
1868    
1869            /**
1870            * Returns the number of d d m structures where groupId = &#63; and classNameId = &#63;.
1871            *
1872            * @param groupId the group ID
1873            * @param classNameId the class name ID
1874            * @return the number of matching d d m structures
1875            * @throws SystemException if a system exception occurred
1876            */
1877            public static int countByG_C(long groupId, long classNameId)
1878                    throws com.liferay.portal.kernel.exception.SystemException {
1879                    return getPersistence().countByG_C(groupId, classNameId);
1880            }
1881    
1882            /**
1883            * Returns the number of d d m structures where groupId = any &#63; and classNameId = &#63;.
1884            *
1885            * @param groupIds the group IDs
1886            * @param classNameId the class name ID
1887            * @return the number of matching d d m structures
1888            * @throws SystemException if a system exception occurred
1889            */
1890            public static int countByG_C(long[] groupIds, long classNameId)
1891                    throws com.liferay.portal.kernel.exception.SystemException {
1892                    return getPersistence().countByG_C(groupIds, classNameId);
1893            }
1894    
1895            /**
1896            * Returns the number of d d m structures that the user has permission to view where groupId = &#63; and classNameId = &#63;.
1897            *
1898            * @param groupId the group ID
1899            * @param classNameId the class name ID
1900            * @return the number of matching d d m structures that the user has permission to view
1901            * @throws SystemException if a system exception occurred
1902            */
1903            public static int filterCountByG_C(long groupId, long classNameId)
1904                    throws com.liferay.portal.kernel.exception.SystemException {
1905                    return getPersistence().filterCountByG_C(groupId, classNameId);
1906            }
1907    
1908            /**
1909            * Returns the number of d d m structures that the user has permission to view where groupId = any &#63; and classNameId = &#63;.
1910            *
1911            * @param groupIds the group IDs
1912            * @param classNameId the class name ID
1913            * @return the number of matching d d m structures that the user has permission to view
1914            * @throws SystemException if a system exception occurred
1915            */
1916            public static int filterCountByG_C(long[] groupIds, long classNameId)
1917                    throws com.liferay.portal.kernel.exception.SystemException {
1918                    return getPersistence().filterCountByG_C(groupIds, classNameId);
1919            }
1920    
1921            /**
1922            * Returns all the d d m structures where companyId = &#63; and classNameId = &#63;.
1923            *
1924            * @param companyId the company ID
1925            * @param classNameId the class name ID
1926            * @return the matching d d m structures
1927            * @throws SystemException if a system exception occurred
1928            */
1929            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByC_C(
1930                    long companyId, long classNameId)
1931                    throws com.liferay.portal.kernel.exception.SystemException {
1932                    return getPersistence().findByC_C(companyId, classNameId);
1933            }
1934    
1935            /**
1936            * Returns a range of all the d d m structures where companyId = &#63; and classNameId = &#63;.
1937            *
1938            * <p>
1939            * 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.
1940            * </p>
1941            *
1942            * @param companyId the company ID
1943            * @param classNameId the class name ID
1944            * @param start the lower bound of the range of d d m structures
1945            * @param end the upper bound of the range of d d m structures (not inclusive)
1946            * @return the range of matching d d m structures
1947            * @throws SystemException if a system exception occurred
1948            */
1949            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByC_C(
1950                    long companyId, long classNameId, int start, int end)
1951                    throws com.liferay.portal.kernel.exception.SystemException {
1952                    return getPersistence().findByC_C(companyId, classNameId, start, end);
1953            }
1954    
1955            /**
1956            * Returns an ordered range of all the d d m structures where companyId = &#63; and classNameId = &#63;.
1957            *
1958            * <p>
1959            * 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.
1960            * </p>
1961            *
1962            * @param companyId the company ID
1963            * @param classNameId the class name ID
1964            * @param start the lower bound of the range of d d m structures
1965            * @param end the upper bound of the range of d d m structures (not inclusive)
1966            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1967            * @return the ordered range of matching d d m structures
1968            * @throws SystemException if a system exception occurred
1969            */
1970            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByC_C(
1971                    long companyId, long classNameId, int start, int end,
1972                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1973                    throws com.liferay.portal.kernel.exception.SystemException {
1974                    return getPersistence()
1975                                       .findByC_C(companyId, classNameId, start, end,
1976                            orderByComparator);
1977            }
1978    
1979            /**
1980            * Returns the first d d m structure in the ordered set where companyId = &#63; and classNameId = &#63;.
1981            *
1982            * @param companyId the company ID
1983            * @param classNameId the class name ID
1984            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1985            * @return the first matching d d m structure
1986            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
1987            * @throws SystemException if a system exception occurred
1988            */
1989            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByC_C_First(
1990                    long companyId, long classNameId,
1991                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1992                    throws com.liferay.portal.kernel.exception.SystemException,
1993                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1994                    return getPersistence()
1995                                       .findByC_C_First(companyId, classNameId, orderByComparator);
1996            }
1997    
1998            /**
1999            * Returns the first d d m structure in the ordered set where companyId = &#63; and classNameId = &#63;.
2000            *
2001            * @param companyId the company ID
2002            * @param classNameId the class name ID
2003            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2004            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
2005            * @throws SystemException if a system exception occurred
2006            */
2007            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByC_C_First(
2008                    long companyId, long classNameId,
2009                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2010                    throws com.liferay.portal.kernel.exception.SystemException {
2011                    return getPersistence()
2012                                       .fetchByC_C_First(companyId, classNameId, orderByComparator);
2013            }
2014    
2015            /**
2016            * Returns the last d d m structure in the ordered set where companyId = &#63; and classNameId = &#63;.
2017            *
2018            * @param companyId the company ID
2019            * @param classNameId the class name ID
2020            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2021            * @return the last matching d d m structure
2022            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
2023            * @throws SystemException if a system exception occurred
2024            */
2025            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByC_C_Last(
2026                    long companyId, long classNameId,
2027                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2028                    throws com.liferay.portal.kernel.exception.SystemException,
2029                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
2030                    return getPersistence()
2031                                       .findByC_C_Last(companyId, classNameId, orderByComparator);
2032            }
2033    
2034            /**
2035            * Returns the last d d m structure in the ordered set where companyId = &#63; and classNameId = &#63;.
2036            *
2037            * @param companyId the company ID
2038            * @param classNameId the class name ID
2039            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2040            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
2041            * @throws SystemException if a system exception occurred
2042            */
2043            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByC_C_Last(
2044                    long companyId, long classNameId,
2045                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2046                    throws com.liferay.portal.kernel.exception.SystemException {
2047                    return getPersistence()
2048                                       .fetchByC_C_Last(companyId, classNameId, orderByComparator);
2049            }
2050    
2051            /**
2052            * 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;.
2053            *
2054            * @param structureId the primary key of the current d d m structure
2055            * @param companyId the company ID
2056            * @param classNameId the class name ID
2057            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2058            * @return the previous, current, and next d d m structure
2059            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
2060            * @throws SystemException if a system exception occurred
2061            */
2062            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByC_C_PrevAndNext(
2063                    long structureId, long companyId, long classNameId,
2064                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2065                    throws com.liferay.portal.kernel.exception.SystemException,
2066                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
2067                    return getPersistence()
2068                                       .findByC_C_PrevAndNext(structureId, companyId, classNameId,
2069                            orderByComparator);
2070            }
2071    
2072            /**
2073            * Removes all the d d m structures where companyId = &#63; and classNameId = &#63; from the database.
2074            *
2075            * @param companyId the company ID
2076            * @param classNameId the class name ID
2077            * @throws SystemException if a system exception occurred
2078            */
2079            public static void removeByC_C(long companyId, long classNameId)
2080                    throws com.liferay.portal.kernel.exception.SystemException {
2081                    getPersistence().removeByC_C(companyId, classNameId);
2082            }
2083    
2084            /**
2085            * Returns the number of d d m structures where companyId = &#63; and classNameId = &#63;.
2086            *
2087            * @param companyId the company ID
2088            * @param classNameId the class name ID
2089            * @return the number of matching d d m structures
2090            * @throws SystemException if a system exception occurred
2091            */
2092            public static int countByC_C(long companyId, long classNameId)
2093                    throws com.liferay.portal.kernel.exception.SystemException {
2094                    return getPersistence().countByC_C(companyId, classNameId);
2095            }
2096    
2097            /**
2098            * 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.
2099            *
2100            * @param groupId the group ID
2101            * @param classNameId the class name ID
2102            * @param structureKey the structure key
2103            * @return the matching d d m structure
2104            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
2105            * @throws SystemException if a system exception occurred
2106            */
2107            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByG_C_S(
2108                    long groupId, long classNameId, java.lang.String structureKey)
2109                    throws com.liferay.portal.kernel.exception.SystemException,
2110                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
2111                    return getPersistence().findByG_C_S(groupId, classNameId, structureKey);
2112            }
2113    
2114            /**
2115            * 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.
2116            *
2117            * @param groupId the group ID
2118            * @param classNameId the class name ID
2119            * @param structureKey the structure key
2120            * @return the matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
2121            * @throws SystemException if a system exception occurred
2122            */
2123            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_C_S(
2124                    long groupId, long classNameId, java.lang.String structureKey)
2125                    throws com.liferay.portal.kernel.exception.SystemException {
2126                    return getPersistence().fetchByG_C_S(groupId, classNameId, structureKey);
2127            }
2128    
2129            /**
2130            * 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.
2131            *
2132            * @param groupId the group ID
2133            * @param classNameId the class name ID
2134            * @param structureKey the structure key
2135            * @param retrieveFromCache whether to use the finder cache
2136            * @return the matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
2137            * @throws SystemException if a system exception occurred
2138            */
2139            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_C_S(
2140                    long groupId, long classNameId, java.lang.String structureKey,
2141                    boolean retrieveFromCache)
2142                    throws com.liferay.portal.kernel.exception.SystemException {
2143                    return getPersistence()
2144                                       .fetchByG_C_S(groupId, classNameId, structureKey,
2145                            retrieveFromCache);
2146            }
2147    
2148            /**
2149            * Removes the d d m structure where groupId = &#63; and classNameId = &#63; and structureKey = &#63; from the database.
2150            *
2151            * @param groupId the group ID
2152            * @param classNameId the class name ID
2153            * @param structureKey the structure key
2154            * @return the d d m structure that was removed
2155            * @throws SystemException if a system exception occurred
2156            */
2157            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure removeByG_C_S(
2158                    long groupId, long classNameId, java.lang.String structureKey)
2159                    throws com.liferay.portal.kernel.exception.SystemException,
2160                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
2161                    return getPersistence().removeByG_C_S(groupId, classNameId, structureKey);
2162            }
2163    
2164            /**
2165            * Returns the number of d d m structures where groupId = &#63; and classNameId = &#63; and structureKey = &#63;.
2166            *
2167            * @param groupId the group ID
2168            * @param classNameId the class name ID
2169            * @param structureKey the structure key
2170            * @return the number of matching d d m structures
2171            * @throws SystemException if a system exception occurred
2172            */
2173            public static int countByG_C_S(long groupId, long classNameId,
2174                    java.lang.String structureKey)
2175                    throws com.liferay.portal.kernel.exception.SystemException {
2176                    return getPersistence().countByG_C_S(groupId, classNameId, structureKey);
2177            }
2178    
2179            /**
2180            * Returns all the d d m structures where groupId = &#63; and name = &#63; and description = &#63;.
2181            *
2182            * @param groupId the group ID
2183            * @param name the name
2184            * @param description the description
2185            * @return the matching d d m structures
2186            * @throws SystemException if a system exception occurred
2187            */
2188            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_N_D(
2189                    long groupId, java.lang.String name, java.lang.String description)
2190                    throws com.liferay.portal.kernel.exception.SystemException {
2191                    return getPersistence().findByG_N_D(groupId, name, description);
2192            }
2193    
2194            /**
2195            * Returns a range of all the d d m structures where groupId = &#63; and name = &#63; and description = &#63;.
2196            *
2197            * <p>
2198            * 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.
2199            * </p>
2200            *
2201            * @param groupId the group ID
2202            * @param name the name
2203            * @param description the description
2204            * @param start the lower bound of the range of d d m structures
2205            * @param end the upper bound of the range of d d m structures (not inclusive)
2206            * @return the range of matching d d m structures
2207            * @throws SystemException if a system exception occurred
2208            */
2209            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_N_D(
2210                    long groupId, java.lang.String name, java.lang.String description,
2211                    int start, int end)
2212                    throws com.liferay.portal.kernel.exception.SystemException {
2213                    return getPersistence()
2214                                       .findByG_N_D(groupId, name, description, start, end);
2215            }
2216    
2217            /**
2218            * Returns an ordered range of all the d d m structures where groupId = &#63; and name = &#63; and description = &#63;.
2219            *
2220            * <p>
2221            * 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.
2222            * </p>
2223            *
2224            * @param groupId the group ID
2225            * @param name the name
2226            * @param description the description
2227            * @param start the lower bound of the range of d d m structures
2228            * @param end the upper bound of the range of d d m structures (not inclusive)
2229            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2230            * @return the ordered range of matching d d m structures
2231            * @throws SystemException if a system exception occurred
2232            */
2233            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_N_D(
2234                    long groupId, java.lang.String name, java.lang.String description,
2235                    int start, int end,
2236                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2237                    throws com.liferay.portal.kernel.exception.SystemException {
2238                    return getPersistence()
2239                                       .findByG_N_D(groupId, name, description, start, end,
2240                            orderByComparator);
2241            }
2242    
2243            /**
2244            * Returns the first d d m structure in the ordered set where groupId = &#63; and name = &#63; and description = &#63;.
2245            *
2246            * @param groupId the group ID
2247            * @param name the name
2248            * @param description the description
2249            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2250            * @return the first matching d d m structure
2251            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
2252            * @throws SystemException if a system exception occurred
2253            */
2254            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByG_N_D_First(
2255                    long groupId, java.lang.String name, java.lang.String description,
2256                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2257                    throws com.liferay.portal.kernel.exception.SystemException,
2258                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
2259                    return getPersistence()
2260                                       .findByG_N_D_First(groupId, name, description,
2261                            orderByComparator);
2262            }
2263    
2264            /**
2265            * Returns the first d d m structure in the ordered set where groupId = &#63; and name = &#63; and description = &#63;.
2266            *
2267            * @param groupId the group ID
2268            * @param name the name
2269            * @param description the description
2270            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2271            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
2272            * @throws SystemException if a system exception occurred
2273            */
2274            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_N_D_First(
2275                    long groupId, java.lang.String name, java.lang.String description,
2276                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2277                    throws com.liferay.portal.kernel.exception.SystemException {
2278                    return getPersistence()
2279                                       .fetchByG_N_D_First(groupId, name, description,
2280                            orderByComparator);
2281            }
2282    
2283            /**
2284            * Returns the last d d m structure in the ordered set where groupId = &#63; and name = &#63; and description = &#63;.
2285            *
2286            * @param groupId the group ID
2287            * @param name the name
2288            * @param description the description
2289            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2290            * @return the last matching d d m structure
2291            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
2292            * @throws SystemException if a system exception occurred
2293            */
2294            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByG_N_D_Last(
2295                    long groupId, java.lang.String name, java.lang.String description,
2296                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2297                    throws com.liferay.portal.kernel.exception.SystemException,
2298                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
2299                    return getPersistence()
2300                                       .findByG_N_D_Last(groupId, name, description,
2301                            orderByComparator);
2302            }
2303    
2304            /**
2305            * Returns the last d d m structure in the ordered set where groupId = &#63; and name = &#63; and description = &#63;.
2306            *
2307            * @param groupId the group ID
2308            * @param name the name
2309            * @param description the description
2310            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2311            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
2312            * @throws SystemException if a system exception occurred
2313            */
2314            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_N_D_Last(
2315                    long groupId, java.lang.String name, java.lang.String description,
2316                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2317                    throws com.liferay.portal.kernel.exception.SystemException {
2318                    return getPersistence()
2319                                       .fetchByG_N_D_Last(groupId, name, description,
2320                            orderByComparator);
2321            }
2322    
2323            /**
2324            * 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;.
2325            *
2326            * @param structureId the primary key of the current d d m structure
2327            * @param groupId the group ID
2328            * @param name the name
2329            * @param description the description
2330            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2331            * @return the previous, current, and next d d m structure
2332            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
2333            * @throws SystemException if a system exception occurred
2334            */
2335            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByG_N_D_PrevAndNext(
2336                    long structureId, long groupId, java.lang.String name,
2337                    java.lang.String description,
2338                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2339                    throws com.liferay.portal.kernel.exception.SystemException,
2340                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
2341                    return getPersistence()
2342                                       .findByG_N_D_PrevAndNext(structureId, groupId, name,
2343                            description, orderByComparator);
2344            }
2345    
2346            /**
2347            * Returns all the d d m structures that the user has permission to view where groupId = &#63; and name = &#63; and description = &#63;.
2348            *
2349            * @param groupId the group ID
2350            * @param name the name
2351            * @param description the description
2352            * @return the matching d d m structures that the user has permission to view
2353            * @throws SystemException if a system exception occurred
2354            */
2355            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_N_D(
2356                    long groupId, java.lang.String name, java.lang.String description)
2357                    throws com.liferay.portal.kernel.exception.SystemException {
2358                    return getPersistence().filterFindByG_N_D(groupId, name, description);
2359            }
2360    
2361            /**
2362            * 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;.
2363            *
2364            * <p>
2365            * 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.
2366            * </p>
2367            *
2368            * @param groupId the group ID
2369            * @param name the name
2370            * @param description the description
2371            * @param start the lower bound of the range of d d m structures
2372            * @param end the upper bound of the range of d d m structures (not inclusive)
2373            * @return the range of matching d d m structures that the user has permission to view
2374            * @throws SystemException if a system exception occurred
2375            */
2376            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_N_D(
2377                    long groupId, java.lang.String name, java.lang.String description,
2378                    int start, int end)
2379                    throws com.liferay.portal.kernel.exception.SystemException {
2380                    return getPersistence()
2381                                       .filterFindByG_N_D(groupId, name, description, start, end);
2382            }
2383    
2384            /**
2385            * 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;.
2386            *
2387            * <p>
2388            * 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.
2389            * </p>
2390            *
2391            * @param groupId the group ID
2392            * @param name the name
2393            * @param description the description
2394            * @param start the lower bound of the range of d d m structures
2395            * @param end the upper bound of the range of d d m structures (not inclusive)
2396            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2397            * @return the ordered range of matching d d m structures that the user has permission to view
2398            * @throws SystemException if a system exception occurred
2399            */
2400            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_N_D(
2401                    long groupId, java.lang.String name, java.lang.String description,
2402                    int start, int end,
2403                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2404                    throws com.liferay.portal.kernel.exception.SystemException {
2405                    return getPersistence()
2406                                       .filterFindByG_N_D(groupId, name, description, start, end,
2407                            orderByComparator);
2408            }
2409    
2410            /**
2411            * 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;.
2412            *
2413            * @param structureId the primary key of the current d d m structure
2414            * @param groupId the group ID
2415            * @param name the name
2416            * @param description the description
2417            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2418            * @return the previous, current, and next d d m structure
2419            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
2420            * @throws SystemException if a system exception occurred
2421            */
2422            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] filterFindByG_N_D_PrevAndNext(
2423                    long structureId, long groupId, java.lang.String name,
2424                    java.lang.String description,
2425                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2426                    throws com.liferay.portal.kernel.exception.SystemException,
2427                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
2428                    return getPersistence()
2429                                       .filterFindByG_N_D_PrevAndNext(structureId, groupId, name,
2430                            description, orderByComparator);
2431            }
2432    
2433            /**
2434            * Removes all the d d m structures where groupId = &#63; and name = &#63; and description = &#63; from the database.
2435            *
2436            * @param groupId the group ID
2437            * @param name the name
2438            * @param description the description
2439            * @throws SystemException if a system exception occurred
2440            */
2441            public static void removeByG_N_D(long groupId, java.lang.String name,
2442                    java.lang.String description)
2443                    throws com.liferay.portal.kernel.exception.SystemException {
2444                    getPersistence().removeByG_N_D(groupId, name, description);
2445            }
2446    
2447            /**
2448            * Returns the number of d d m structures where groupId = &#63; and name = &#63; and description = &#63;.
2449            *
2450            * @param groupId the group ID
2451            * @param name the name
2452            * @param description the description
2453            * @return the number of matching d d m structures
2454            * @throws SystemException if a system exception occurred
2455            */
2456            public static int countByG_N_D(long groupId, java.lang.String name,
2457                    java.lang.String description)
2458                    throws com.liferay.portal.kernel.exception.SystemException {
2459                    return getPersistence().countByG_N_D(groupId, name, description);
2460            }
2461    
2462            /**
2463            * Returns the number of d d m structures that the user has permission to view where groupId = &#63; and name = &#63; and description = &#63;.
2464            *
2465            * @param groupId the group ID
2466            * @param name the name
2467            * @param description the description
2468            * @return the number of matching d d m structures that the user has permission to view
2469            * @throws SystemException if a system exception occurred
2470            */
2471            public static int filterCountByG_N_D(long groupId, java.lang.String name,
2472                    java.lang.String description)
2473                    throws com.liferay.portal.kernel.exception.SystemException {
2474                    return getPersistence().filterCountByG_N_D(groupId, name, description);
2475            }
2476    
2477            /**
2478            * Caches the d d m structure in the entity cache if it is enabled.
2479            *
2480            * @param ddmStructure the d d m structure
2481            */
2482            public static void cacheResult(
2483                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure) {
2484                    getPersistence().cacheResult(ddmStructure);
2485            }
2486    
2487            /**
2488            * Caches the d d m structures in the entity cache if it is enabled.
2489            *
2490            * @param ddmStructures the d d m structures
2491            */
2492            public static void cacheResult(
2493                    java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> ddmStructures) {
2494                    getPersistence().cacheResult(ddmStructures);
2495            }
2496    
2497            /**
2498            * Creates a new d d m structure with the primary key. Does not add the d d m structure to the database.
2499            *
2500            * @param structureId the primary key for the new d d m structure
2501            * @return the new d d m structure
2502            */
2503            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure create(
2504                    long structureId) {
2505                    return getPersistence().create(structureId);
2506            }
2507    
2508            /**
2509            * Removes the d d m structure with the primary key from the database. Also notifies the appropriate model listeners.
2510            *
2511            * @param structureId the primary key of the d d m structure
2512            * @return the d d m structure that was removed
2513            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
2514            * @throws SystemException if a system exception occurred
2515            */
2516            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure remove(
2517                    long structureId)
2518                    throws com.liferay.portal.kernel.exception.SystemException,
2519                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
2520                    return getPersistence().remove(structureId);
2521            }
2522    
2523            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure updateImpl(
2524                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure)
2525                    throws com.liferay.portal.kernel.exception.SystemException {
2526                    return getPersistence().updateImpl(ddmStructure);
2527            }
2528    
2529            /**
2530            * 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.
2531            *
2532            * @param structureId the primary key of the d d m structure
2533            * @return the d d m structure
2534            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
2535            * @throws SystemException if a system exception occurred
2536            */
2537            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByPrimaryKey(
2538                    long structureId)
2539                    throws com.liferay.portal.kernel.exception.SystemException,
2540                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
2541                    return getPersistence().findByPrimaryKey(structureId);
2542            }
2543    
2544            /**
2545            * Returns the d d m structure with the primary key or returns <code>null</code> if it could not be found.
2546            *
2547            * @param structureId the primary key of the d d m structure
2548            * @return the d d m structure, or <code>null</code> if a d d m structure with the primary key could not be found
2549            * @throws SystemException if a system exception occurred
2550            */
2551            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByPrimaryKey(
2552                    long structureId)
2553                    throws com.liferay.portal.kernel.exception.SystemException {
2554                    return getPersistence().fetchByPrimaryKey(structureId);
2555            }
2556    
2557            /**
2558            * Returns all the d d m structures.
2559            *
2560            * @return the d d m structures
2561            * @throws SystemException if a system exception occurred
2562            */
2563            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findAll()
2564                    throws com.liferay.portal.kernel.exception.SystemException {
2565                    return getPersistence().findAll();
2566            }
2567    
2568            /**
2569            * Returns a range of all the d d m structures.
2570            *
2571            * <p>
2572            * 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.
2573            * </p>
2574            *
2575            * @param start the lower bound of the range of d d m structures
2576            * @param end the upper bound of the range of d d m structures (not inclusive)
2577            * @return the range of d d m structures
2578            * @throws SystemException if a system exception occurred
2579            */
2580            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findAll(
2581                    int start, int end)
2582                    throws com.liferay.portal.kernel.exception.SystemException {
2583                    return getPersistence().findAll(start, end);
2584            }
2585    
2586            /**
2587            * Returns an ordered range of all the d d m structures.
2588            *
2589            * <p>
2590            * 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.
2591            * </p>
2592            *
2593            * @param start the lower bound of the range of d d m structures
2594            * @param end the upper bound of the range of d d m structures (not inclusive)
2595            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2596            * @return the ordered range of d d m structures
2597            * @throws SystemException if a system exception occurred
2598            */
2599            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findAll(
2600                    int start, int end,
2601                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2602                    throws com.liferay.portal.kernel.exception.SystemException {
2603                    return getPersistence().findAll(start, end, orderByComparator);
2604            }
2605    
2606            /**
2607            * Removes all the d d m structures from the database.
2608            *
2609            * @throws SystemException if a system exception occurred
2610            */
2611            public static void removeAll()
2612                    throws com.liferay.portal.kernel.exception.SystemException {
2613                    getPersistence().removeAll();
2614            }
2615    
2616            /**
2617            * Returns the number of d d m structures.
2618            *
2619            * @return the number of d d m structures
2620            * @throws SystemException if a system exception occurred
2621            */
2622            public static int countAll()
2623                    throws com.liferay.portal.kernel.exception.SystemException {
2624                    return getPersistence().countAll();
2625            }
2626    
2627            /**
2628            * Returns all the document library file entry types associated with the d d m structure.
2629            *
2630            * @param pk the primary key of the d d m structure
2631            * @return the document library file entry types associated with the d d m structure
2632            * @throws SystemException if a system exception occurred
2633            */
2634            public static java.util.List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> getDLFileEntryTypes(
2635                    long pk) throws com.liferay.portal.kernel.exception.SystemException {
2636                    return getPersistence().getDLFileEntryTypes(pk);
2637            }
2638    
2639            /**
2640            * Returns a range of all the document library file entry types associated with the d d m structure.
2641            *
2642            * <p>
2643            * 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.
2644            * </p>
2645            *
2646            * @param pk the primary key of the d d m structure
2647            * @param start the lower bound of the range of d d m structures
2648            * @param end the upper bound of the range of d d m structures (not inclusive)
2649            * @return the range of document library file entry types associated with the d d m structure
2650            * @throws SystemException if a system exception occurred
2651            */
2652            public static java.util.List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> getDLFileEntryTypes(
2653                    long pk, int start, int end)
2654                    throws com.liferay.portal.kernel.exception.SystemException {
2655                    return getPersistence().getDLFileEntryTypes(pk, start, end);
2656            }
2657    
2658            /**
2659            * Returns an ordered range of all the document library file entry types associated with the d d m structure.
2660            *
2661            * <p>
2662            * 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.
2663            * </p>
2664            *
2665            * @param pk the primary key of the d d m structure
2666            * @param start the lower bound of the range of d d m structures
2667            * @param end the upper bound of the range of d d m structures (not inclusive)
2668            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2669            * @return the ordered range of document library file entry types associated with the d d m structure
2670            * @throws SystemException if a system exception occurred
2671            */
2672            public static java.util.List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> getDLFileEntryTypes(
2673                    long pk, int start, int end,
2674                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2675                    throws com.liferay.portal.kernel.exception.SystemException {
2676                    return getPersistence()
2677                                       .getDLFileEntryTypes(pk, start, end, orderByComparator);
2678            }
2679    
2680            /**
2681            * Returns the number of document library file entry types associated with the d d m structure.
2682            *
2683            * @param pk the primary key of the d d m structure
2684            * @return the number of document library file entry types associated with the d d m structure
2685            * @throws SystemException if a system exception occurred
2686            */
2687            public static int getDLFileEntryTypesSize(long pk)
2688                    throws com.liferay.portal.kernel.exception.SystemException {
2689                    return getPersistence().getDLFileEntryTypesSize(pk);
2690            }
2691    
2692            /**
2693            * Returns <code>true</code> if the document library file entry type is associated with the d d m structure.
2694            *
2695            * @param pk the primary key of the d d m structure
2696            * @param dlFileEntryTypePK the primary key of the document library file entry type
2697            * @return <code>true</code> if the document library file entry type is associated with the d d m structure; <code>false</code> otherwise
2698            * @throws SystemException if a system exception occurred
2699            */
2700            public static boolean containsDLFileEntryType(long pk,
2701                    long dlFileEntryTypePK)
2702                    throws com.liferay.portal.kernel.exception.SystemException {
2703                    return getPersistence().containsDLFileEntryType(pk, dlFileEntryTypePK);
2704            }
2705    
2706            /**
2707            * Returns <code>true</code> if the d d m structure has any document library file entry types associated with it.
2708            *
2709            * @param pk the primary key of the d d m structure to check for associations with document library file entry types
2710            * @return <code>true</code> if the d d m structure has any document library file entry types associated with it; <code>false</code> otherwise
2711            * @throws SystemException if a system exception occurred
2712            */
2713            public static boolean containsDLFileEntryTypes(long pk)
2714                    throws com.liferay.portal.kernel.exception.SystemException {
2715                    return getPersistence().containsDLFileEntryTypes(pk);
2716            }
2717    
2718            /**
2719            * Adds an association between the d d m structure and the document library file entry type. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2720            *
2721            * @param pk the primary key of the d d m structure
2722            * @param dlFileEntryTypePK the primary key of the document library file entry type
2723            * @throws SystemException if a system exception occurred
2724            */
2725            public static void addDLFileEntryType(long pk, long dlFileEntryTypePK)
2726                    throws com.liferay.portal.kernel.exception.SystemException {
2727                    getPersistence().addDLFileEntryType(pk, dlFileEntryTypePK);
2728            }
2729    
2730            /**
2731            * Adds an association between the d d m structure and the document library file entry type. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2732            *
2733            * @param pk the primary key of the d d m structure
2734            * @param dlFileEntryType the document library file entry type
2735            * @throws SystemException if a system exception occurred
2736            */
2737            public static void addDLFileEntryType(long pk,
2738                    com.liferay.portlet.documentlibrary.model.DLFileEntryType dlFileEntryType)
2739                    throws com.liferay.portal.kernel.exception.SystemException {
2740                    getPersistence().addDLFileEntryType(pk, dlFileEntryType);
2741            }
2742    
2743            /**
2744            * Adds an association between the d d m structure and the document library file entry types. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2745            *
2746            * @param pk the primary key of the d d m structure
2747            * @param dlFileEntryTypePKs the primary keys of the document library file entry types
2748            * @throws SystemException if a system exception occurred
2749            */
2750            public static void addDLFileEntryTypes(long pk, long[] dlFileEntryTypePKs)
2751                    throws com.liferay.portal.kernel.exception.SystemException {
2752                    getPersistence().addDLFileEntryTypes(pk, dlFileEntryTypePKs);
2753            }
2754    
2755            /**
2756            * Adds an association between the d d m structure and the document library file entry types. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2757            *
2758            * @param pk the primary key of the d d m structure
2759            * @param dlFileEntryTypes the document library file entry types
2760            * @throws SystemException if a system exception occurred
2761            */
2762            public static void addDLFileEntryTypes(long pk,
2763                    java.util.List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> dlFileEntryTypes)
2764                    throws com.liferay.portal.kernel.exception.SystemException {
2765                    getPersistence().addDLFileEntryTypes(pk, dlFileEntryTypes);
2766            }
2767    
2768            /**
2769            * Clears all associations between the d d m structure and its document library file entry types. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2770            *
2771            * @param pk the primary key of the d d m structure to clear the associated document library file entry types from
2772            * @throws SystemException if a system exception occurred
2773            */
2774            public static void clearDLFileEntryTypes(long pk)
2775                    throws com.liferay.portal.kernel.exception.SystemException {
2776                    getPersistence().clearDLFileEntryTypes(pk);
2777            }
2778    
2779            /**
2780            * Removes the association between the d d m structure and the document library file entry type. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2781            *
2782            * @param pk the primary key of the d d m structure
2783            * @param dlFileEntryTypePK the primary key of the document library file entry type
2784            * @throws SystemException if a system exception occurred
2785            */
2786            public static void removeDLFileEntryType(long pk, long dlFileEntryTypePK)
2787                    throws com.liferay.portal.kernel.exception.SystemException {
2788                    getPersistence().removeDLFileEntryType(pk, dlFileEntryTypePK);
2789            }
2790    
2791            /**
2792            * Removes the association between the d d m structure and the document library file entry type. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2793            *
2794            * @param pk the primary key of the d d m structure
2795            * @param dlFileEntryType the document library file entry type
2796            * @throws SystemException if a system exception occurred
2797            */
2798            public static void removeDLFileEntryType(long pk,
2799                    com.liferay.portlet.documentlibrary.model.DLFileEntryType dlFileEntryType)
2800                    throws com.liferay.portal.kernel.exception.SystemException {
2801                    getPersistence().removeDLFileEntryType(pk, dlFileEntryType);
2802            }
2803    
2804            /**
2805            * Removes the association between the d d m structure and the document library file entry types. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2806            *
2807            * @param pk the primary key of the d d m structure
2808            * @param dlFileEntryTypePKs the primary keys of the document library file entry types
2809            * @throws SystemException if a system exception occurred
2810            */
2811            public static void removeDLFileEntryTypes(long pk, long[] dlFileEntryTypePKs)
2812                    throws com.liferay.portal.kernel.exception.SystemException {
2813                    getPersistence().removeDLFileEntryTypes(pk, dlFileEntryTypePKs);
2814            }
2815    
2816            /**
2817            * Removes the association between the d d m structure and the document library file entry types. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2818            *
2819            * @param pk the primary key of the d d m structure
2820            * @param dlFileEntryTypes the document library file entry types
2821            * @throws SystemException if a system exception occurred
2822            */
2823            public static void removeDLFileEntryTypes(long pk,
2824                    java.util.List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> dlFileEntryTypes)
2825                    throws com.liferay.portal.kernel.exception.SystemException {
2826                    getPersistence().removeDLFileEntryTypes(pk, dlFileEntryTypes);
2827            }
2828    
2829            /**
2830            * Sets the document library file entry types associated with the d d m structure, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2831            *
2832            * @param pk the primary key of the d d m structure
2833            * @param dlFileEntryTypePKs the primary keys of the document library file entry types to be associated with the d d m structure
2834            * @throws SystemException if a system exception occurred
2835            */
2836            public static void setDLFileEntryTypes(long pk, long[] dlFileEntryTypePKs)
2837                    throws com.liferay.portal.kernel.exception.SystemException {
2838                    getPersistence().setDLFileEntryTypes(pk, dlFileEntryTypePKs);
2839            }
2840    
2841            /**
2842            * Sets the document library file entry types associated with the d d m structure, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2843            *
2844            * @param pk the primary key of the d d m structure
2845            * @param dlFileEntryTypes the document library file entry types to be associated with the d d m structure
2846            * @throws SystemException if a system exception occurred
2847            */
2848            public static void setDLFileEntryTypes(long pk,
2849                    java.util.List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> dlFileEntryTypes)
2850                    throws com.liferay.portal.kernel.exception.SystemException {
2851                    getPersistence().setDLFileEntryTypes(pk, dlFileEntryTypes);
2852            }
2853    
2854            public static DDMStructurePersistence getPersistence() {
2855                    if (_persistence == null) {
2856                            _persistence = (DDMStructurePersistence)PortalBeanLocatorUtil.locate(DDMStructurePersistence.class.getName());
2857    
2858                            ReferenceRegistry.registerReference(DDMStructureUtil.class,
2859                                    "_persistence");
2860                    }
2861    
2862                    return _persistence;
2863            }
2864    
2865            /**
2866             * @deprecated As of 6.2.0
2867             */
2868            public void setPersistence(DDMStructurePersistence persistence) {
2869            }
2870    
2871            private static DDMStructurePersistence _persistence;
2872    }