001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.dynamicdatamapping.service.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
020    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
021    import com.liferay.portal.kernel.util.OrderByComparator;
022    import com.liferay.portal.kernel.util.ReferenceRegistry;
023    import com.liferay.portal.service.ServiceContext;
024    
025    import com.liferay.portlet.dynamicdatamapping.model.DDMStructure;
026    
027    import java.util.List;
028    
029    /**
030     * The persistence utility for the d d m structure service. This utility wraps {@link com.liferay.portlet.dynamicdatamapping.service.persistence.impl.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.
031     *
032     * <p>
033     * Caching information and settings can be found in <code>portal.properties</code>
034     * </p>
035     *
036     * @author Brian Wing Shun Chan
037     * @see DDMStructurePersistence
038     * @see com.liferay.portlet.dynamicdatamapping.service.persistence.impl.DDMStructurePersistenceImpl
039     * @generated
040     */
041    @ProviderType
042    public class DDMStructureUtil {
043            /*
044             * NOTE FOR DEVELOPERS:
045             *
046             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
047             */
048    
049            /**
050             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
051             */
052            public static void clearCache() {
053                    getPersistence().clearCache();
054            }
055    
056            /**
057             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
058             */
059            public static void clearCache(DDMStructure ddmStructure) {
060                    getPersistence().clearCache(ddmStructure);
061            }
062    
063            /**
064             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
065             */
066            public static long countWithDynamicQuery(DynamicQuery dynamicQuery) {
067                    return getPersistence().countWithDynamicQuery(dynamicQuery);
068            }
069    
070            /**
071             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
072             */
073            public static List<DDMStructure> findWithDynamicQuery(
074                    DynamicQuery dynamicQuery) {
075                    return getPersistence().findWithDynamicQuery(dynamicQuery);
076            }
077    
078            /**
079             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
080             */
081            public static List<DDMStructure> findWithDynamicQuery(
082                    DynamicQuery dynamicQuery, int start, int end) {
083                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
084            }
085    
086            /**
087             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
088             */
089            public static List<DDMStructure> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator<DDMStructure> orderByComparator) {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
099             */
100            public static DDMStructure update(DDMStructure ddmStructure) {
101                    return getPersistence().update(ddmStructure);
102            }
103    
104            /**
105             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
106             */
107            public static DDMStructure update(DDMStructure ddmStructure,
108                    ServiceContext serviceContext) {
109                    return getPersistence().update(ddmStructure, serviceContext);
110            }
111    
112            /**
113            * Returns all the d d m structures where uuid = &#63;.
114            *
115            * @param uuid the uuid
116            * @return the matching d d m structures
117            */
118            public static List<DDMStructure> findByUuid(java.lang.String uuid) {
119                    return getPersistence().findByUuid(uuid);
120            }
121    
122            /**
123            * Returns a range of all the d d m structures where uuid = &#63;.
124            *
125            * <p>
126            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
127            * </p>
128            *
129            * @param uuid the uuid
130            * @param start the lower bound of the range of d d m structures
131            * @param end the upper bound of the range of d d m structures (not inclusive)
132            * @return the range of matching d d m structures
133            */
134            public static List<DDMStructure> findByUuid(java.lang.String uuid,
135                    int start, int end) {
136                    return getPersistence().findByUuid(uuid, start, end);
137            }
138    
139            /**
140            * Returns an ordered range of all the d d m structures where uuid = &#63;.
141            *
142            * <p>
143            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
144            * </p>
145            *
146            * @param uuid the uuid
147            * @param start the lower bound of the range of d d m structures
148            * @param end the upper bound of the range of d d m structures (not inclusive)
149            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
150            * @return the ordered range of matching d d m structures
151            */
152            public static List<DDMStructure> findByUuid(java.lang.String uuid,
153                    int start, int end, OrderByComparator<DDMStructure> orderByComparator) {
154                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
155            }
156    
157            /**
158            * Returns the first d d m structure in the ordered set where uuid = &#63;.
159            *
160            * @param uuid the uuid
161            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
162            * @return the first matching d d m structure
163            * @throws NoSuchStructureException if a matching d d m structure could not be found
164            */
165            public static DDMStructure findByUuid_First(java.lang.String uuid,
166                    OrderByComparator<DDMStructure> orderByComparator)
167                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
168                    return getPersistence().findByUuid_First(uuid, orderByComparator);
169            }
170    
171            /**
172            * Returns the first d d m structure in the ordered set where uuid = &#63;.
173            *
174            * @param uuid the uuid
175            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
176            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
177            */
178            public static DDMStructure fetchByUuid_First(java.lang.String uuid,
179                    OrderByComparator<DDMStructure> orderByComparator) {
180                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
181            }
182    
183            /**
184            * Returns the last 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 last matching d d m structure
189            * @throws NoSuchStructureException if a matching d d m structure could not be found
190            */
191            public static DDMStructure findByUuid_Last(java.lang.String uuid,
192                    OrderByComparator<DDMStructure> orderByComparator)
193                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
194                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
195            }
196    
197            /**
198            * Returns the last d d m structure in the ordered set where uuid = &#63;.
199            *
200            * @param uuid the uuid
201            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
202            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
203            */
204            public static DDMStructure fetchByUuid_Last(java.lang.String uuid,
205                    OrderByComparator<DDMStructure> orderByComparator) {
206                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
207            }
208    
209            /**
210            * Returns the d d m structures before and after the current d d m structure in the ordered set where uuid = &#63;.
211            *
212            * @param structureId the primary key of the current d d m structure
213            * @param uuid the uuid
214            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
215            * @return the previous, current, and next d d m structure
216            * @throws NoSuchStructureException if a d d m structure with the primary key could not be found
217            */
218            public static DDMStructure[] findByUuid_PrevAndNext(long structureId,
219                    java.lang.String uuid, OrderByComparator<DDMStructure> orderByComparator)
220                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
221                    return getPersistence()
222                                       .findByUuid_PrevAndNext(structureId, uuid, orderByComparator);
223            }
224    
225            /**
226            * Removes all the d d m structures where uuid = &#63; from the database.
227            *
228            * @param uuid the uuid
229            */
230            public static void removeByUuid(java.lang.String uuid) {
231                    getPersistence().removeByUuid(uuid);
232            }
233    
234            /**
235            * Returns the number of d d m structures where uuid = &#63;.
236            *
237            * @param uuid the uuid
238            * @return the number of matching d d m structures
239            */
240            public static int countByUuid(java.lang.String uuid) {
241                    return getPersistence().countByUuid(uuid);
242            }
243    
244            /**
245            * Returns the d d m structure where uuid = &#63; and groupId = &#63; or throws a {@link NoSuchStructureException} if it could not be found.
246            *
247            * @param uuid the uuid
248            * @param groupId the group ID
249            * @return the matching d d m structure
250            * @throws NoSuchStructureException if a matching d d m structure could not be found
251            */
252            public static DDMStructure findByUUID_G(java.lang.String uuid, long groupId)
253                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
254                    return getPersistence().findByUUID_G(uuid, groupId);
255            }
256    
257            /**
258            * 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.
259            *
260            * @param uuid the uuid
261            * @param groupId the group ID
262            * @return the matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
263            */
264            public static DDMStructure fetchByUUID_G(java.lang.String uuid, long groupId) {
265                    return getPersistence().fetchByUUID_G(uuid, groupId);
266            }
267    
268            /**
269            * 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.
270            *
271            * @param uuid the uuid
272            * @param groupId the group ID
273            * @param retrieveFromCache whether to use the finder cache
274            * @return the matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
275            */
276            public static DDMStructure fetchByUUID_G(java.lang.String uuid,
277                    long groupId, boolean retrieveFromCache) {
278                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
279            }
280    
281            /**
282            * Removes the d d m structure where uuid = &#63; and groupId = &#63; from the database.
283            *
284            * @param uuid the uuid
285            * @param groupId the group ID
286            * @return the d d m structure that was removed
287            */
288            public static DDMStructure removeByUUID_G(java.lang.String uuid,
289                    long groupId)
290                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
291                    return getPersistence().removeByUUID_G(uuid, groupId);
292            }
293    
294            /**
295            * Returns the number of d d m structures where uuid = &#63; and groupId = &#63;.
296            *
297            * @param uuid the uuid
298            * @param groupId the group ID
299            * @return the number of matching d d m structures
300            */
301            public static int countByUUID_G(java.lang.String uuid, long groupId) {
302                    return getPersistence().countByUUID_G(uuid, groupId);
303            }
304    
305            /**
306            * Returns all the d d m structures where uuid = &#63; and companyId = &#63;.
307            *
308            * @param uuid the uuid
309            * @param companyId the company ID
310            * @return the matching d d m structures
311            */
312            public static List<DDMStructure> findByUuid_C(java.lang.String uuid,
313                    long companyId) {
314                    return getPersistence().findByUuid_C(uuid, companyId);
315            }
316    
317            /**
318            * Returns a range of all the d d m structures where uuid = &#63; and companyId = &#63;.
319            *
320            * <p>
321            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
322            * </p>
323            *
324            * @param uuid the uuid
325            * @param companyId the company ID
326            * @param start the lower bound of the range of d d m structures
327            * @param end the upper bound of the range of d d m structures (not inclusive)
328            * @return the range of matching d d m structures
329            */
330            public static List<DDMStructure> findByUuid_C(java.lang.String uuid,
331                    long companyId, int start, int end) {
332                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
333            }
334    
335            /**
336            * Returns an ordered range of all the d d m structures where uuid = &#63; and companyId = &#63;.
337            *
338            * <p>
339            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
340            * </p>
341            *
342            * @param uuid the uuid
343            * @param companyId the company ID
344            * @param start the lower bound of the range of d d m structures
345            * @param end the upper bound of the range of d d m structures (not inclusive)
346            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
347            * @return the ordered range of matching d d m structures
348            */
349            public static List<DDMStructure> findByUuid_C(java.lang.String uuid,
350                    long companyId, int start, int end,
351                    OrderByComparator<DDMStructure> orderByComparator) {
352                    return getPersistence()
353                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
354            }
355    
356            /**
357            * Returns the first d d m structure in the ordered set where uuid = &#63; and companyId = &#63;.
358            *
359            * @param uuid the uuid
360            * @param companyId the company ID
361            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
362            * @return the first matching d d m structure
363            * @throws NoSuchStructureException if a matching d d m structure could not be found
364            */
365            public static DDMStructure findByUuid_C_First(java.lang.String uuid,
366                    long companyId, OrderByComparator<DDMStructure> orderByComparator)
367                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
368                    return getPersistence()
369                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
370            }
371    
372            /**
373            * Returns the first d d m structure in the ordered set where uuid = &#63; and companyId = &#63;.
374            *
375            * @param uuid the uuid
376            * @param companyId the company ID
377            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
378            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
379            */
380            public static DDMStructure fetchByUuid_C_First(java.lang.String uuid,
381                    long companyId, OrderByComparator<DDMStructure> orderByComparator) {
382                    return getPersistence()
383                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
384            }
385    
386            /**
387            * Returns the last d d m structure in the ordered set where uuid = &#63; and companyId = &#63;.
388            *
389            * @param uuid the uuid
390            * @param companyId the company ID
391            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
392            * @return the last matching d d m structure
393            * @throws NoSuchStructureException if a matching d d m structure could not be found
394            */
395            public static DDMStructure findByUuid_C_Last(java.lang.String uuid,
396                    long companyId, OrderByComparator<DDMStructure> orderByComparator)
397                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
398                    return getPersistence()
399                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
400            }
401    
402            /**
403            * Returns the last 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 last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
409            */
410            public static DDMStructure fetchByUuid_C_Last(java.lang.String uuid,
411                    long companyId, OrderByComparator<DDMStructure> orderByComparator) {
412                    return getPersistence()
413                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
414            }
415    
416            /**
417            * 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;.
418            *
419            * @param structureId the primary key of the current d d m structure
420            * @param uuid the uuid
421            * @param companyId the company ID
422            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
423            * @return the previous, current, and next d d m structure
424            * @throws NoSuchStructureException if a d d m structure with the primary key could not be found
425            */
426            public static DDMStructure[] findByUuid_C_PrevAndNext(long structureId,
427                    java.lang.String uuid, long companyId,
428                    OrderByComparator<DDMStructure> orderByComparator)
429                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
430                    return getPersistence()
431                                       .findByUuid_C_PrevAndNext(structureId, uuid, companyId,
432                            orderByComparator);
433            }
434    
435            /**
436            * Removes all the d d m structures where uuid = &#63; and companyId = &#63; from the database.
437            *
438            * @param uuid the uuid
439            * @param companyId the company ID
440            */
441            public static void removeByUuid_C(java.lang.String uuid, long companyId) {
442                    getPersistence().removeByUuid_C(uuid, companyId);
443            }
444    
445            /**
446            * Returns the number of d d m structures where uuid = &#63; and companyId = &#63;.
447            *
448            * @param uuid the uuid
449            * @param companyId the company ID
450            * @return the number of matching d d m structures
451            */
452            public static int countByUuid_C(java.lang.String uuid, long companyId) {
453                    return getPersistence().countByUuid_C(uuid, companyId);
454            }
455    
456            /**
457            * Returns all the d d m structures where groupId = &#63;.
458            *
459            * @param groupId the group ID
460            * @return the matching d d m structures
461            */
462            public static List<DDMStructure> findByGroupId(long groupId) {
463                    return getPersistence().findByGroupId(groupId);
464            }
465    
466            /**
467            * Returns a range of all the d d m structures where groupId = &#63;.
468            *
469            * <p>
470            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
471            * </p>
472            *
473            * @param groupId the group ID
474            * @param start the lower bound of the range of d d m structures
475            * @param end the upper bound of the range of d d m structures (not inclusive)
476            * @return the range of matching d d m structures
477            */
478            public static List<DDMStructure> findByGroupId(long groupId, int start,
479                    int end) {
480                    return getPersistence().findByGroupId(groupId, start, end);
481            }
482    
483            /**
484            * Returns an ordered range of all the d d m structures where groupId = &#63;.
485            *
486            * <p>
487            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
488            * </p>
489            *
490            * @param groupId the group ID
491            * @param start the lower bound of the range of d d m structures
492            * @param end the upper bound of the range of d d m structures (not inclusive)
493            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
494            * @return the ordered range of matching d d m structures
495            */
496            public static List<DDMStructure> findByGroupId(long groupId, int start,
497                    int end, OrderByComparator<DDMStructure> orderByComparator) {
498                    return getPersistence()
499                                       .findByGroupId(groupId, start, end, orderByComparator);
500            }
501    
502            /**
503            * Returns the first d d m structure in the ordered set where groupId = &#63;.
504            *
505            * @param groupId the group ID
506            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
507            * @return the first matching d d m structure
508            * @throws NoSuchStructureException if a matching d d m structure could not be found
509            */
510            public static DDMStructure findByGroupId_First(long groupId,
511                    OrderByComparator<DDMStructure> orderByComparator)
512                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
513                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
514            }
515    
516            /**
517            * Returns the first d d m structure in the ordered set where groupId = &#63;.
518            *
519            * @param groupId the group ID
520            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
521            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
522            */
523            public static DDMStructure fetchByGroupId_First(long groupId,
524                    OrderByComparator<DDMStructure> orderByComparator) {
525                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
526            }
527    
528            /**
529            * Returns the last d d m structure in the ordered set where groupId = &#63;.
530            *
531            * @param groupId the group ID
532            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
533            * @return the last matching d d m structure
534            * @throws NoSuchStructureException if a matching d d m structure could not be found
535            */
536            public static DDMStructure findByGroupId_Last(long groupId,
537                    OrderByComparator<DDMStructure> orderByComparator)
538                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
539                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
540            }
541    
542            /**
543            * Returns the last d d m structure in the ordered set where groupId = &#63;.
544            *
545            * @param groupId the group ID
546            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
547            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
548            */
549            public static DDMStructure fetchByGroupId_Last(long groupId,
550                    OrderByComparator<DDMStructure> orderByComparator) {
551                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
552            }
553    
554            /**
555            * Returns the d d m structures before and after the current d d m structure in the ordered set where groupId = &#63;.
556            *
557            * @param structureId the primary key of the current d d m structure
558            * @param groupId the group ID
559            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
560            * @return the previous, current, and next d d m structure
561            * @throws NoSuchStructureException if a d d m structure with the primary key could not be found
562            */
563            public static DDMStructure[] findByGroupId_PrevAndNext(long structureId,
564                    long groupId, OrderByComparator<DDMStructure> orderByComparator)
565                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
566                    return getPersistence()
567                                       .findByGroupId_PrevAndNext(structureId, groupId,
568                            orderByComparator);
569            }
570    
571            /**
572            * Returns all the d d m structures that the user has permission to view where groupId = &#63;.
573            *
574            * @param groupId the group ID
575            * @return the matching d d m structures that the user has permission to view
576            */
577            public static List<DDMStructure> filterFindByGroupId(long groupId) {
578                    return getPersistence().filterFindByGroupId(groupId);
579            }
580    
581            /**
582            * Returns a range of all the d d m structures that the user has permission to view where groupId = &#63;.
583            *
584            * <p>
585            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
586            * </p>
587            *
588            * @param groupId the group ID
589            * @param start the lower bound of the range of d d m structures
590            * @param end the upper bound of the range of d d m structures (not inclusive)
591            * @return the range of matching d d m structures that the user has permission to view
592            */
593            public static List<DDMStructure> filterFindByGroupId(long groupId,
594                    int start, int end) {
595                    return getPersistence().filterFindByGroupId(groupId, start, end);
596            }
597    
598            /**
599            * Returns an ordered range of all the d d m structures that the user has permissions to view where groupId = &#63;.
600            *
601            * <p>
602            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
603            * </p>
604            *
605            * @param groupId the group ID
606            * @param start the lower bound of the range of d d m structures
607            * @param end the upper bound of the range of d d m structures (not inclusive)
608            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
609            * @return the ordered range of matching d d m structures that the user has permission to view
610            */
611            public static List<DDMStructure> filterFindByGroupId(long groupId,
612                    int start, int end, OrderByComparator<DDMStructure> orderByComparator) {
613                    return getPersistence()
614                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
615            }
616    
617            /**
618            * 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;.
619            *
620            * @param structureId the primary key of the current d d m structure
621            * @param groupId the group ID
622            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
623            * @return the previous, current, and next d d m structure
624            * @throws NoSuchStructureException if a d d m structure with the primary key could not be found
625            */
626            public static DDMStructure[] filterFindByGroupId_PrevAndNext(
627                    long structureId, long groupId,
628                    OrderByComparator<DDMStructure> orderByComparator)
629                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
630                    return getPersistence()
631                                       .filterFindByGroupId_PrevAndNext(structureId, groupId,
632                            orderByComparator);
633            }
634    
635            /**
636            * Returns all the d d m structures that the user has permission to view where groupId = any &#63;.
637            *
638            * @param groupIds the group IDs
639            * @return the matching d d m structures that the user has permission to view
640            */
641            public static List<DDMStructure> filterFindByGroupId(long[] groupIds) {
642                    return getPersistence().filterFindByGroupId(groupIds);
643            }
644    
645            /**
646            * Returns a range of all the d d m structures that the user has permission to view where groupId = any &#63;.
647            *
648            * <p>
649            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
650            * </p>
651            *
652            * @param groupIds the group IDs
653            * @param start the lower bound of the range of d d m structures
654            * @param end the upper bound of the range of d d m structures (not inclusive)
655            * @return the range of matching d d m structures that the user has permission to view
656            */
657            public static List<DDMStructure> filterFindByGroupId(long[] groupIds,
658                    int start, int end) {
659                    return getPersistence().filterFindByGroupId(groupIds, start, end);
660            }
661    
662            /**
663            * Returns an ordered range of all the d d m structures that the user has permission to view where groupId = any &#63;.
664            *
665            * <p>
666            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
667            * </p>
668            *
669            * @param groupIds the group IDs
670            * @param start the lower bound of the range of d d m structures
671            * @param end the upper bound of the range of d d m structures (not inclusive)
672            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
673            * @return the ordered range of matching d d m structures that the user has permission to view
674            */
675            public static List<DDMStructure> filterFindByGroupId(long[] groupIds,
676                    int start, int end, OrderByComparator<DDMStructure> orderByComparator) {
677                    return getPersistence()
678                                       .filterFindByGroupId(groupIds, start, end, orderByComparator);
679            }
680    
681            /**
682            * Returns all the d d m structures where groupId = any &#63;.
683            *
684            * <p>
685            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
686            * </p>
687            *
688            * @param groupIds the group IDs
689            * @return the matching d d m structures
690            */
691            public static List<DDMStructure> findByGroupId(long[] groupIds) {
692                    return getPersistence().findByGroupId(groupIds);
693            }
694    
695            /**
696            * Returns a range of all the d d m structures where groupId = any &#63;.
697            *
698            * <p>
699            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
700            * </p>
701            *
702            * @param groupIds the group IDs
703            * @param start the lower bound of the range of d d m structures
704            * @param end the upper bound of the range of d d m structures (not inclusive)
705            * @return the range of matching d d m structures
706            */
707            public static List<DDMStructure> findByGroupId(long[] groupIds, int start,
708                    int end) {
709                    return getPersistence().findByGroupId(groupIds, start, end);
710            }
711    
712            /**
713            * Returns an ordered range of all the d d m structures where groupId = any &#63;.
714            *
715            * <p>
716            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
717            * </p>
718            *
719            * @param groupIds the group IDs
720            * @param start the lower bound of the range of d d m structures
721            * @param end the upper bound of the range of d d m structures (not inclusive)
722            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
723            * @return the ordered range of matching d d m structures
724            */
725            public static List<DDMStructure> findByGroupId(long[] groupIds, int start,
726                    int end, OrderByComparator<DDMStructure> orderByComparator) {
727                    return getPersistence()
728                                       .findByGroupId(groupIds, start, end, orderByComparator);
729            }
730    
731            /**
732            * Removes all the d d m structures where groupId = &#63; from the database.
733            *
734            * @param groupId the group ID
735            */
736            public static void removeByGroupId(long groupId) {
737                    getPersistence().removeByGroupId(groupId);
738            }
739    
740            /**
741            * Returns the number of d d m structures where groupId = &#63;.
742            *
743            * @param groupId the group ID
744            * @return the number of matching d d m structures
745            */
746            public static int countByGroupId(long groupId) {
747                    return getPersistence().countByGroupId(groupId);
748            }
749    
750            /**
751            * Returns the number of d d m structures where groupId = any &#63;.
752            *
753            * @param groupIds the group IDs
754            * @return the number of matching d d m structures
755            */
756            public static int countByGroupId(long[] groupIds) {
757                    return getPersistence().countByGroupId(groupIds);
758            }
759    
760            /**
761            * Returns the number of d d m structures that the user has permission to view where groupId = &#63;.
762            *
763            * @param groupId the group ID
764            * @return the number of matching d d m structures that the user has permission to view
765            */
766            public static int filterCountByGroupId(long groupId) {
767                    return getPersistence().filterCountByGroupId(groupId);
768            }
769    
770            /**
771            * Returns the number of d d m structures that the user has permission to view where groupId = any &#63;.
772            *
773            * @param groupIds the group IDs
774            * @return the number of matching d d m structures that the user has permission to view
775            */
776            public static int filterCountByGroupId(long[] groupIds) {
777                    return getPersistence().filterCountByGroupId(groupIds);
778            }
779    
780            /**
781            * Returns all the d d m structures where parentStructureId = &#63;.
782            *
783            * @param parentStructureId the parent structure ID
784            * @return the matching d d m structures
785            */
786            public static List<DDMStructure> findByParentStructureId(
787                    long parentStructureId) {
788                    return getPersistence().findByParentStructureId(parentStructureId);
789            }
790    
791            /**
792            * Returns a range of all the d d m structures where parentStructureId = &#63;.
793            *
794            * <p>
795            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
796            * </p>
797            *
798            * @param parentStructureId the parent structure ID
799            * @param start the lower bound of the range of d d m structures
800            * @param end the upper bound of the range of d d m structures (not inclusive)
801            * @return the range of matching d d m structures
802            */
803            public static List<DDMStructure> findByParentStructureId(
804                    long parentStructureId, int start, int end) {
805                    return getPersistence()
806                                       .findByParentStructureId(parentStructureId, start, end);
807            }
808    
809            /**
810            * Returns an ordered range of all the d d m structures where parentStructureId = &#63;.
811            *
812            * <p>
813            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
814            * </p>
815            *
816            * @param parentStructureId the parent structure ID
817            * @param start the lower bound of the range of d d m structures
818            * @param end the upper bound of the range of d d m structures (not inclusive)
819            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
820            * @return the ordered range of matching d d m structures
821            */
822            public static List<DDMStructure> findByParentStructureId(
823                    long parentStructureId, int start, int end,
824                    OrderByComparator<DDMStructure> orderByComparator) {
825                    return getPersistence()
826                                       .findByParentStructureId(parentStructureId, start, end,
827                            orderByComparator);
828            }
829    
830            /**
831            * Returns the first d d m structure in the ordered set where parentStructureId = &#63;.
832            *
833            * @param parentStructureId the parent structure ID
834            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
835            * @return the first matching d d m structure
836            * @throws NoSuchStructureException if a matching d d m structure could not be found
837            */
838            public static DDMStructure findByParentStructureId_First(
839                    long parentStructureId,
840                    OrderByComparator<DDMStructure> orderByComparator)
841                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
842                    return getPersistence()
843                                       .findByParentStructureId_First(parentStructureId,
844                            orderByComparator);
845            }
846    
847            /**
848            * Returns the first d d m structure in the ordered set where parentStructureId = &#63;.
849            *
850            * @param parentStructureId the parent structure ID
851            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
852            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
853            */
854            public static DDMStructure fetchByParentStructureId_First(
855                    long parentStructureId,
856                    OrderByComparator<DDMStructure> orderByComparator) {
857                    return getPersistence()
858                                       .fetchByParentStructureId_First(parentStructureId,
859                            orderByComparator);
860            }
861    
862            /**
863            * Returns the last d d m structure in the ordered set where parentStructureId = &#63;.
864            *
865            * @param parentStructureId the parent structure ID
866            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
867            * @return the last matching d d m structure
868            * @throws NoSuchStructureException if a matching d d m structure could not be found
869            */
870            public static DDMStructure findByParentStructureId_Last(
871                    long parentStructureId,
872                    OrderByComparator<DDMStructure> orderByComparator)
873                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
874                    return getPersistence()
875                                       .findByParentStructureId_Last(parentStructureId,
876                            orderByComparator);
877            }
878    
879            /**
880            * Returns the last d d m structure in the ordered set where parentStructureId = &#63;.
881            *
882            * @param parentStructureId the parent structure ID
883            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
884            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
885            */
886            public static DDMStructure fetchByParentStructureId_Last(
887                    long parentStructureId,
888                    OrderByComparator<DDMStructure> orderByComparator) {
889                    return getPersistence()
890                                       .fetchByParentStructureId_Last(parentStructureId,
891                            orderByComparator);
892            }
893    
894            /**
895            * Returns the d d m structures before and after the current d d m structure in the ordered set where parentStructureId = &#63;.
896            *
897            * @param structureId the primary key of the current d d m structure
898            * @param parentStructureId the parent structure ID
899            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
900            * @return the previous, current, and next d d m structure
901            * @throws NoSuchStructureException if a d d m structure with the primary key could not be found
902            */
903            public static DDMStructure[] findByParentStructureId_PrevAndNext(
904                    long structureId, long parentStructureId,
905                    OrderByComparator<DDMStructure> orderByComparator)
906                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
907                    return getPersistence()
908                                       .findByParentStructureId_PrevAndNext(structureId,
909                            parentStructureId, orderByComparator);
910            }
911    
912            /**
913            * Removes all the d d m structures where parentStructureId = &#63; from the database.
914            *
915            * @param parentStructureId the parent structure ID
916            */
917            public static void removeByParentStructureId(long parentStructureId) {
918                    getPersistence().removeByParentStructureId(parentStructureId);
919            }
920    
921            /**
922            * Returns the number of d d m structures where parentStructureId = &#63;.
923            *
924            * @param parentStructureId the parent structure ID
925            * @return the number of matching d d m structures
926            */
927            public static int countByParentStructureId(long parentStructureId) {
928                    return getPersistence().countByParentStructureId(parentStructureId);
929            }
930    
931            /**
932            * Returns all the d d m structures where classNameId = &#63;.
933            *
934            * @param classNameId the class name ID
935            * @return the matching d d m structures
936            */
937            public static List<DDMStructure> findByClassNameId(long classNameId) {
938                    return getPersistence().findByClassNameId(classNameId);
939            }
940    
941            /**
942            * Returns a range of all the d d m structures where classNameId = &#63;.
943            *
944            * <p>
945            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
946            * </p>
947            *
948            * @param classNameId the class name ID
949            * @param start the lower bound of the range of d d m structures
950            * @param end the upper bound of the range of d d m structures (not inclusive)
951            * @return the range of matching d d m structures
952            */
953            public static List<DDMStructure> findByClassNameId(long classNameId,
954                    int start, int end) {
955                    return getPersistence().findByClassNameId(classNameId, start, end);
956            }
957    
958            /**
959            * Returns an ordered range of all the d d m structures where classNameId = &#63;.
960            *
961            * <p>
962            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
963            * </p>
964            *
965            * @param classNameId the class name ID
966            * @param start the lower bound of the range of d d m structures
967            * @param end the upper bound of the range of d d m structures (not inclusive)
968            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
969            * @return the ordered range of matching d d m structures
970            */
971            public static List<DDMStructure> findByClassNameId(long classNameId,
972                    int start, int end, OrderByComparator<DDMStructure> orderByComparator) {
973                    return getPersistence()
974                                       .findByClassNameId(classNameId, start, end, orderByComparator);
975            }
976    
977            /**
978            * Returns the first d d m structure in the ordered set where classNameId = &#63;.
979            *
980            * @param classNameId the class name ID
981            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
982            * @return the first matching d d m structure
983            * @throws NoSuchStructureException if a matching d d m structure could not be found
984            */
985            public static DDMStructure findByClassNameId_First(long classNameId,
986                    OrderByComparator<DDMStructure> orderByComparator)
987                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
988                    return getPersistence()
989                                       .findByClassNameId_First(classNameId, orderByComparator);
990            }
991    
992            /**
993            * Returns the first d d m structure in the ordered set where classNameId = &#63;.
994            *
995            * @param classNameId the class name ID
996            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
997            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
998            */
999            public static DDMStructure fetchByClassNameId_First(long classNameId,
1000                    OrderByComparator<DDMStructure> orderByComparator) {
1001                    return getPersistence()
1002                                       .fetchByClassNameId_First(classNameId, orderByComparator);
1003            }
1004    
1005            /**
1006            * Returns the last d d m structure in the ordered set where classNameId = &#63;.
1007            *
1008            * @param classNameId the class name ID
1009            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1010            * @return the last matching d d m structure
1011            * @throws NoSuchStructureException if a matching d d m structure could not be found
1012            */
1013            public static DDMStructure findByClassNameId_Last(long classNameId,
1014                    OrderByComparator<DDMStructure> orderByComparator)
1015                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1016                    return getPersistence()
1017                                       .findByClassNameId_Last(classNameId, orderByComparator);
1018            }
1019    
1020            /**
1021            * Returns the last d d m structure in the ordered set where classNameId = &#63;.
1022            *
1023            * @param classNameId the class name ID
1024            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1025            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1026            */
1027            public static DDMStructure fetchByClassNameId_Last(long classNameId,
1028                    OrderByComparator<DDMStructure> orderByComparator) {
1029                    return getPersistence()
1030                                       .fetchByClassNameId_Last(classNameId, orderByComparator);
1031            }
1032    
1033            /**
1034            * Returns the d d m structures before and after the current d d m structure in the ordered set where classNameId = &#63;.
1035            *
1036            * @param structureId the primary key of the current d d m structure
1037            * @param classNameId the class name ID
1038            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1039            * @return the previous, current, and next d d m structure
1040            * @throws NoSuchStructureException if a d d m structure with the primary key could not be found
1041            */
1042            public static DDMStructure[] findByClassNameId_PrevAndNext(
1043                    long structureId, long classNameId,
1044                    OrderByComparator<DDMStructure> orderByComparator)
1045                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1046                    return getPersistence()
1047                                       .findByClassNameId_PrevAndNext(structureId, classNameId,
1048                            orderByComparator);
1049            }
1050    
1051            /**
1052            * Removes all the d d m structures where classNameId = &#63; from the database.
1053            *
1054            * @param classNameId the class name ID
1055            */
1056            public static void removeByClassNameId(long classNameId) {
1057                    getPersistence().removeByClassNameId(classNameId);
1058            }
1059    
1060            /**
1061            * Returns the number of d d m structures where classNameId = &#63;.
1062            *
1063            * @param classNameId the class name ID
1064            * @return the number of matching d d m structures
1065            */
1066            public static int countByClassNameId(long classNameId) {
1067                    return getPersistence().countByClassNameId(classNameId);
1068            }
1069    
1070            /**
1071            * Returns all the d d m structures where structureKey = &#63;.
1072            *
1073            * @param structureKey the structure key
1074            * @return the matching d d m structures
1075            */
1076            public static List<DDMStructure> findByStructureKey(
1077                    java.lang.String structureKey) {
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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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            */
1093            public static List<DDMStructure> findByStructureKey(
1094                    java.lang.String structureKey, int start, int end) {
1095                    return getPersistence().findByStructureKey(structureKey, start, end);
1096            }
1097    
1098            /**
1099            * Returns an ordered range of all the d d m structures where structureKey = &#63;.
1100            *
1101            * <p>
1102            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1103            * </p>
1104            *
1105            * @param structureKey the structure key
1106            * @param start the lower bound of the range of d d m structures
1107            * @param end the upper bound of the range of d d m structures (not inclusive)
1108            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1109            * @return the ordered range of matching d d m structures
1110            */
1111            public static List<DDMStructure> findByStructureKey(
1112                    java.lang.String structureKey, int start, int end,
1113                    OrderByComparator<DDMStructure> orderByComparator) {
1114                    return getPersistence()
1115                                       .findByStructureKey(structureKey, start, end,
1116                            orderByComparator);
1117            }
1118    
1119            /**
1120            * Returns the first d d m structure in the ordered set where structureKey = &#63;.
1121            *
1122            * @param structureKey the structure key
1123            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1124            * @return the first matching d d m structure
1125            * @throws NoSuchStructureException if a matching d d m structure could not be found
1126            */
1127            public static DDMStructure findByStructureKey_First(
1128                    java.lang.String structureKey,
1129                    OrderByComparator<DDMStructure> orderByComparator)
1130                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1131                    return getPersistence()
1132                                       .findByStructureKey_First(structureKey, orderByComparator);
1133            }
1134    
1135            /**
1136            * Returns the first d d m structure in the ordered set where structureKey = &#63;.
1137            *
1138            * @param structureKey the structure key
1139            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1140            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1141            */
1142            public static DDMStructure fetchByStructureKey_First(
1143                    java.lang.String structureKey,
1144                    OrderByComparator<DDMStructure> orderByComparator) {
1145                    return getPersistence()
1146                                       .fetchByStructureKey_First(structureKey, orderByComparator);
1147            }
1148    
1149            /**
1150            * Returns the last d d m structure in the ordered set where structureKey = &#63;.
1151            *
1152            * @param structureKey the structure key
1153            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1154            * @return the last matching d d m structure
1155            * @throws NoSuchStructureException if a matching d d m structure could not be found
1156            */
1157            public static DDMStructure findByStructureKey_Last(
1158                    java.lang.String structureKey,
1159                    OrderByComparator<DDMStructure> orderByComparator)
1160                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1161                    return getPersistence()
1162                                       .findByStructureKey_Last(structureKey, orderByComparator);
1163            }
1164    
1165            /**
1166            * Returns the last d d m structure in the ordered set where structureKey = &#63;.
1167            *
1168            * @param structureKey the structure key
1169            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1170            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1171            */
1172            public static DDMStructure fetchByStructureKey_Last(
1173                    java.lang.String structureKey,
1174                    OrderByComparator<DDMStructure> orderByComparator) {
1175                    return getPersistence()
1176                                       .fetchByStructureKey_Last(structureKey, orderByComparator);
1177            }
1178    
1179            /**
1180            * Returns the d d m structures before and after the current d d m structure in the ordered set where structureKey = &#63;.
1181            *
1182            * @param structureId the primary key of the current d d m structure
1183            * @param structureKey the structure key
1184            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1185            * @return the previous, current, and next d d m structure
1186            * @throws NoSuchStructureException if a d d m structure with the primary key could not be found
1187            */
1188            public static DDMStructure[] findByStructureKey_PrevAndNext(
1189                    long structureId, java.lang.String structureKey,
1190                    OrderByComparator<DDMStructure> orderByComparator)
1191                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1192                    return getPersistence()
1193                                       .findByStructureKey_PrevAndNext(structureId, structureKey,
1194                            orderByComparator);
1195            }
1196    
1197            /**
1198            * Removes all the d d m structures where structureKey = &#63; from the database.
1199            *
1200            * @param structureKey the structure key
1201            */
1202            public static void removeByStructureKey(java.lang.String structureKey) {
1203                    getPersistence().removeByStructureKey(structureKey);
1204            }
1205    
1206            /**
1207            * Returns the number of d d m structures where structureKey = &#63;.
1208            *
1209            * @param structureKey the structure key
1210            * @return the number of matching d d m structures
1211            */
1212            public static int countByStructureKey(java.lang.String structureKey) {
1213                    return getPersistence().countByStructureKey(structureKey);
1214            }
1215    
1216            /**
1217            * Returns all the d d m structures where groupId = &#63; and parentStructureId = &#63;.
1218            *
1219            * @param groupId the group ID
1220            * @param parentStructureId the parent structure ID
1221            * @return the matching d d m structures
1222            */
1223            public static List<DDMStructure> findByG_P(long groupId,
1224                    long parentStructureId) {
1225                    return getPersistence().findByG_P(groupId, parentStructureId);
1226            }
1227    
1228            /**
1229            * Returns a range of all the d d m structures where groupId = &#63; and parentStructureId = &#63;.
1230            *
1231            * <p>
1232            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1233            * </p>
1234            *
1235            * @param groupId the group ID
1236            * @param parentStructureId the parent structure ID
1237            * @param start the lower bound of the range of d d m structures
1238            * @param end the upper bound of the range of d d m structures (not inclusive)
1239            * @return the range of matching d d m structures
1240            */
1241            public static List<DDMStructure> findByG_P(long groupId,
1242                    long parentStructureId, int start, int end) {
1243                    return getPersistence().findByG_P(groupId, parentStructureId, start, end);
1244            }
1245    
1246            /**
1247            * Returns an ordered range of all the d d m structures where groupId = &#63; and parentStructureId = &#63;.
1248            *
1249            * <p>
1250            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1251            * </p>
1252            *
1253            * @param groupId the group ID
1254            * @param parentStructureId the parent structure ID
1255            * @param start the lower bound of the range of d d m structures
1256            * @param end the upper bound of the range of d d m structures (not inclusive)
1257            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1258            * @return the ordered range of matching d d m structures
1259            */
1260            public static List<DDMStructure> findByG_P(long groupId,
1261                    long parentStructureId, int start, int end,
1262                    OrderByComparator<DDMStructure> orderByComparator) {
1263                    return getPersistence()
1264                                       .findByG_P(groupId, parentStructureId, start, end,
1265                            orderByComparator);
1266            }
1267    
1268            /**
1269            * Returns the first d d m structure in the ordered set where groupId = &#63; and parentStructureId = &#63;.
1270            *
1271            * @param groupId the group ID
1272            * @param parentStructureId the parent structure ID
1273            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1274            * @return the first matching d d m structure
1275            * @throws NoSuchStructureException if a matching d d m structure could not be found
1276            */
1277            public static DDMStructure findByG_P_First(long groupId,
1278                    long parentStructureId,
1279                    OrderByComparator<DDMStructure> orderByComparator)
1280                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1281                    return getPersistence()
1282                                       .findByG_P_First(groupId, parentStructureId,
1283                            orderByComparator);
1284            }
1285    
1286            /**
1287            * Returns the first d d m structure in the ordered set where groupId = &#63; and parentStructureId = &#63;.
1288            *
1289            * @param groupId the group ID
1290            * @param parentStructureId the parent structure ID
1291            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1292            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1293            */
1294            public static DDMStructure fetchByG_P_First(long groupId,
1295                    long parentStructureId,
1296                    OrderByComparator<DDMStructure> orderByComparator) {
1297                    return getPersistence()
1298                                       .fetchByG_P_First(groupId, parentStructureId,
1299                            orderByComparator);
1300            }
1301    
1302            /**
1303            * Returns the last d d m structure in the ordered set where groupId = &#63; and parentStructureId = &#63;.
1304            *
1305            * @param groupId the group ID
1306            * @param parentStructureId the parent structure ID
1307            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1308            * @return the last matching d d m structure
1309            * @throws NoSuchStructureException if a matching d d m structure could not be found
1310            */
1311            public static DDMStructure findByG_P_Last(long groupId,
1312                    long parentStructureId,
1313                    OrderByComparator<DDMStructure> orderByComparator)
1314                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1315                    return getPersistence()
1316                                       .findByG_P_Last(groupId, parentStructureId, orderByComparator);
1317            }
1318    
1319            /**
1320            * Returns the last d d m structure in the ordered set where groupId = &#63; and parentStructureId = &#63;.
1321            *
1322            * @param groupId the group ID
1323            * @param parentStructureId the parent structure ID
1324            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1325            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1326            */
1327            public static DDMStructure fetchByG_P_Last(long groupId,
1328                    long parentStructureId,
1329                    OrderByComparator<DDMStructure> orderByComparator) {
1330                    return getPersistence()
1331                                       .fetchByG_P_Last(groupId, parentStructureId,
1332                            orderByComparator);
1333            }
1334    
1335            /**
1336            * 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;.
1337            *
1338            * @param structureId the primary key of the current d d m structure
1339            * @param groupId the group ID
1340            * @param parentStructureId the parent structure ID
1341            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1342            * @return the previous, current, and next d d m structure
1343            * @throws NoSuchStructureException if a d d m structure with the primary key could not be found
1344            */
1345            public static DDMStructure[] findByG_P_PrevAndNext(long structureId,
1346                    long groupId, long parentStructureId,
1347                    OrderByComparator<DDMStructure> orderByComparator)
1348                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1349                    return getPersistence()
1350                                       .findByG_P_PrevAndNext(structureId, groupId,
1351                            parentStructureId, orderByComparator);
1352            }
1353    
1354            /**
1355            * Returns all the d d m structures that the user has permission to view where groupId = &#63; and parentStructureId = &#63;.
1356            *
1357            * @param groupId the group ID
1358            * @param parentStructureId the parent structure ID
1359            * @return the matching d d m structures that the user has permission to view
1360            */
1361            public static List<DDMStructure> filterFindByG_P(long groupId,
1362                    long parentStructureId) {
1363                    return getPersistence().filterFindByG_P(groupId, parentStructureId);
1364            }
1365    
1366            /**
1367            * Returns a range of all the d d m structures that the user has permission to view where groupId = &#63; and parentStructureId = &#63;.
1368            *
1369            * <p>
1370            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1371            * </p>
1372            *
1373            * @param groupId the group ID
1374            * @param parentStructureId the parent structure ID
1375            * @param start the lower bound of the range of d d m structures
1376            * @param end the upper bound of the range of d d m structures (not inclusive)
1377            * @return the range of matching d d m structures that the user has permission to view
1378            */
1379            public static List<DDMStructure> filterFindByG_P(long groupId,
1380                    long parentStructureId, int start, int end) {
1381                    return getPersistence()
1382                                       .filterFindByG_P(groupId, parentStructureId, start, end);
1383            }
1384    
1385            /**
1386            * Returns an ordered range of all the d d m structures that the user has permissions to view where groupId = &#63; and parentStructureId = &#63;.
1387            *
1388            * <p>
1389            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1390            * </p>
1391            *
1392            * @param groupId the group ID
1393            * @param parentStructureId the parent structure ID
1394            * @param start the lower bound of the range of d d m structures
1395            * @param end the upper bound of the range of d d m structures (not inclusive)
1396            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1397            * @return the ordered range of matching d d m structures that the user has permission to view
1398            */
1399            public static List<DDMStructure> filterFindByG_P(long groupId,
1400                    long parentStructureId, int start, int end,
1401                    OrderByComparator<DDMStructure> orderByComparator) {
1402                    return getPersistence()
1403                                       .filterFindByG_P(groupId, parentStructureId, start, end,
1404                            orderByComparator);
1405            }
1406    
1407            /**
1408            * 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;.
1409            *
1410            * @param structureId the primary key of the current d d m structure
1411            * @param groupId the group ID
1412            * @param parentStructureId the parent structure ID
1413            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1414            * @return the previous, current, and next d d m structure
1415            * @throws NoSuchStructureException if a d d m structure with the primary key could not be found
1416            */
1417            public static DDMStructure[] filterFindByG_P_PrevAndNext(long structureId,
1418                    long groupId, long parentStructureId,
1419                    OrderByComparator<DDMStructure> orderByComparator)
1420                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1421                    return getPersistence()
1422                                       .filterFindByG_P_PrevAndNext(structureId, groupId,
1423                            parentStructureId, orderByComparator);
1424            }
1425    
1426            /**
1427            * Removes all the d d m structures where groupId = &#63; and parentStructureId = &#63; from the database.
1428            *
1429            * @param groupId the group ID
1430            * @param parentStructureId the parent structure ID
1431            */
1432            public static void removeByG_P(long groupId, long parentStructureId) {
1433                    getPersistence().removeByG_P(groupId, parentStructureId);
1434            }
1435    
1436            /**
1437            * Returns the number of d d m structures where groupId = &#63; and parentStructureId = &#63;.
1438            *
1439            * @param groupId the group ID
1440            * @param parentStructureId the parent structure ID
1441            * @return the number of matching d d m structures
1442            */
1443            public static int countByG_P(long groupId, long parentStructureId) {
1444                    return getPersistence().countByG_P(groupId, parentStructureId);
1445            }
1446    
1447            /**
1448            * Returns the number of d d m structures that the user has permission to view where groupId = &#63; and parentStructureId = &#63;.
1449            *
1450            * @param groupId the group ID
1451            * @param parentStructureId the parent structure ID
1452            * @return the number of matching d d m structures that the user has permission to view
1453            */
1454            public static int filterCountByG_P(long groupId, long parentStructureId) {
1455                    return getPersistence().filterCountByG_P(groupId, parentStructureId);
1456            }
1457    
1458            /**
1459            * Returns all the d d m structures where groupId = &#63; and classNameId = &#63;.
1460            *
1461            * @param groupId the group ID
1462            * @param classNameId the class name ID
1463            * @return the matching d d m structures
1464            */
1465            public static List<DDMStructure> findByG_C(long groupId, long classNameId) {
1466                    return getPersistence().findByG_C(groupId, classNameId);
1467            }
1468    
1469            /**
1470            * Returns a range of all the d d m structures where groupId = &#63; and classNameId = &#63;.
1471            *
1472            * <p>
1473            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1474            * </p>
1475            *
1476            * @param groupId the group ID
1477            * @param classNameId the class name ID
1478            * @param start the lower bound of the range of d d m structures
1479            * @param end the upper bound of the range of d d m structures (not inclusive)
1480            * @return the range of matching d d m structures
1481            */
1482            public static List<DDMStructure> findByG_C(long groupId, long classNameId,
1483                    int start, int end) {
1484                    return getPersistence().findByG_C(groupId, classNameId, start, end);
1485            }
1486    
1487            /**
1488            * Returns an ordered range of all the d d m structures where groupId = &#63; and classNameId = &#63;.
1489            *
1490            * <p>
1491            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1492            * </p>
1493            *
1494            * @param groupId the group ID
1495            * @param classNameId the class name ID
1496            * @param start the lower bound of the range of d d m structures
1497            * @param end the upper bound of the range of d d m structures (not inclusive)
1498            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1499            * @return the ordered range of matching d d m structures
1500            */
1501            public static List<DDMStructure> findByG_C(long groupId, long classNameId,
1502                    int start, int end, OrderByComparator<DDMStructure> orderByComparator) {
1503                    return getPersistence()
1504                                       .findByG_C(groupId, classNameId, start, end,
1505                            orderByComparator);
1506            }
1507    
1508            /**
1509            * Returns the first d d m structure in the ordered set where groupId = &#63; and classNameId = &#63;.
1510            *
1511            * @param groupId the group ID
1512            * @param classNameId the class name ID
1513            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1514            * @return the first matching d d m structure
1515            * @throws NoSuchStructureException if a matching d d m structure could not be found
1516            */
1517            public static DDMStructure findByG_C_First(long groupId, long classNameId,
1518                    OrderByComparator<DDMStructure> orderByComparator)
1519                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1520                    return getPersistence()
1521                                       .findByG_C_First(groupId, classNameId, orderByComparator);
1522            }
1523    
1524            /**
1525            * Returns the first d d m structure in the ordered set where groupId = &#63; and classNameId = &#63;.
1526            *
1527            * @param groupId the group ID
1528            * @param classNameId the class name ID
1529            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1530            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1531            */
1532            public static DDMStructure fetchByG_C_First(long groupId, long classNameId,
1533                    OrderByComparator<DDMStructure> orderByComparator) {
1534                    return getPersistence()
1535                                       .fetchByG_C_First(groupId, classNameId, orderByComparator);
1536            }
1537    
1538            /**
1539            * Returns the last d d m structure in the ordered set where groupId = &#63; and classNameId = &#63;.
1540            *
1541            * @param groupId the group ID
1542            * @param classNameId the class name ID
1543            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1544            * @return the last matching d d m structure
1545            * @throws NoSuchStructureException if a matching d d m structure could not be found
1546            */
1547            public static DDMStructure findByG_C_Last(long groupId, long classNameId,
1548                    OrderByComparator<DDMStructure> orderByComparator)
1549                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1550                    return getPersistence()
1551                                       .findByG_C_Last(groupId, classNameId, orderByComparator);
1552            }
1553    
1554            /**
1555            * Returns the last d d m structure in the ordered set where groupId = &#63; and classNameId = &#63;.
1556            *
1557            * @param groupId the group ID
1558            * @param classNameId the class name ID
1559            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1560            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1561            */
1562            public static DDMStructure fetchByG_C_Last(long groupId, long classNameId,
1563                    OrderByComparator<DDMStructure> orderByComparator) {
1564                    return getPersistence()
1565                                       .fetchByG_C_Last(groupId, classNameId, orderByComparator);
1566            }
1567    
1568            /**
1569            * 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;.
1570            *
1571            * @param structureId the primary key of the current d d m structure
1572            * @param groupId the group ID
1573            * @param classNameId the class name ID
1574            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1575            * @return the previous, current, and next d d m structure
1576            * @throws NoSuchStructureException if a d d m structure with the primary key could not be found
1577            */
1578            public static DDMStructure[] findByG_C_PrevAndNext(long structureId,
1579                    long groupId, long classNameId,
1580                    OrderByComparator<DDMStructure> orderByComparator)
1581                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1582                    return getPersistence()
1583                                       .findByG_C_PrevAndNext(structureId, groupId, classNameId,
1584                            orderByComparator);
1585            }
1586    
1587            /**
1588            * Returns all the d d m structures that the user has permission to view where groupId = &#63; and classNameId = &#63;.
1589            *
1590            * @param groupId the group ID
1591            * @param classNameId the class name ID
1592            * @return the matching d d m structures that the user has permission to view
1593            */
1594            public static List<DDMStructure> filterFindByG_C(long groupId,
1595                    long classNameId) {
1596                    return getPersistence().filterFindByG_C(groupId, classNameId);
1597            }
1598    
1599            /**
1600            * Returns a range of all the d d m structures that the user has permission to view where groupId = &#63; and classNameId = &#63;.
1601            *
1602            * <p>
1603            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1604            * </p>
1605            *
1606            * @param groupId the group ID
1607            * @param classNameId the class name ID
1608            * @param start the lower bound of the range of d d m structures
1609            * @param end the upper bound of the range of d d m structures (not inclusive)
1610            * @return the range of matching d d m structures that the user has permission to view
1611            */
1612            public static List<DDMStructure> filterFindByG_C(long groupId,
1613                    long classNameId, int start, int end) {
1614                    return getPersistence().filterFindByG_C(groupId, classNameId, start, end);
1615            }
1616    
1617            /**
1618            * Returns an ordered range of all the d d m structures that the user has permissions to view where groupId = &#63; and classNameId = &#63;.
1619            *
1620            * <p>
1621            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1622            * </p>
1623            *
1624            * @param groupId the group ID
1625            * @param classNameId the class name ID
1626            * @param start the lower bound of the range of d d m structures
1627            * @param end the upper bound of the range of d d m structures (not inclusive)
1628            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1629            * @return the ordered range of matching d d m structures that the user has permission to view
1630            */
1631            public static List<DDMStructure> filterFindByG_C(long groupId,
1632                    long classNameId, int start, int end,
1633                    OrderByComparator<DDMStructure> orderByComparator) {
1634                    return getPersistence()
1635                                       .filterFindByG_C(groupId, classNameId, start, end,
1636                            orderByComparator);
1637            }
1638    
1639            /**
1640            * 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;.
1641            *
1642            * @param structureId the primary key of the current d d m structure
1643            * @param groupId the group ID
1644            * @param classNameId the class name ID
1645            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1646            * @return the previous, current, and next d d m structure
1647            * @throws NoSuchStructureException if a d d m structure with the primary key could not be found
1648            */
1649            public static DDMStructure[] filterFindByG_C_PrevAndNext(long structureId,
1650                    long groupId, long classNameId,
1651                    OrderByComparator<DDMStructure> orderByComparator)
1652                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1653                    return getPersistence()
1654                                       .filterFindByG_C_PrevAndNext(structureId, groupId,
1655                            classNameId, orderByComparator);
1656            }
1657    
1658            /**
1659            * Returns all the d d m structures that the user has permission to view where groupId = any &#63; and classNameId = &#63;.
1660            *
1661            * @param groupIds the group IDs
1662            * @param classNameId the class name ID
1663            * @return the matching d d m structures that the user has permission to view
1664            */
1665            public static List<DDMStructure> filterFindByG_C(long[] groupIds,
1666                    long classNameId) {
1667                    return getPersistence().filterFindByG_C(groupIds, classNameId);
1668            }
1669    
1670            /**
1671            * Returns a range of all the d d m structures that the user has permission to view where groupId = any &#63; and classNameId = &#63;.
1672            *
1673            * <p>
1674            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1675            * </p>
1676            *
1677            * @param groupIds the group IDs
1678            * @param classNameId the class name ID
1679            * @param start the lower bound of the range of d d m structures
1680            * @param end the upper bound of the range of d d m structures (not inclusive)
1681            * @return the range of matching d d m structures that the user has permission to view
1682            */
1683            public static List<DDMStructure> filterFindByG_C(long[] groupIds,
1684                    long classNameId, int start, int end) {
1685                    return getPersistence()
1686                                       .filterFindByG_C(groupIds, classNameId, start, end);
1687            }
1688    
1689            /**
1690            * 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;.
1691            *
1692            * <p>
1693            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1694            * </p>
1695            *
1696            * @param groupIds the group IDs
1697            * @param classNameId the class name ID
1698            * @param start the lower bound of the range of d d m structures
1699            * @param end the upper bound of the range of d d m structures (not inclusive)
1700            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1701            * @return the ordered range of matching d d m structures that the user has permission to view
1702            */
1703            public static List<DDMStructure> filterFindByG_C(long[] groupIds,
1704                    long classNameId, int start, int end,
1705                    OrderByComparator<DDMStructure> orderByComparator) {
1706                    return getPersistence()
1707                                       .filterFindByG_C(groupIds, classNameId, start, end,
1708                            orderByComparator);
1709            }
1710    
1711            /**
1712            * Returns all the d d m structures where groupId = any &#63; and classNameId = &#63;.
1713            *
1714            * <p>
1715            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1716            * </p>
1717            *
1718            * @param groupIds the group IDs
1719            * @param classNameId the class name ID
1720            * @return the matching d d m structures
1721            */
1722            public static List<DDMStructure> findByG_C(long[] groupIds, long classNameId) {
1723                    return getPersistence().findByG_C(groupIds, classNameId);
1724            }
1725    
1726            /**
1727            * Returns a range of all the d d m structures where groupId = any &#63; and classNameId = &#63;.
1728            *
1729            * <p>
1730            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1731            * </p>
1732            *
1733            * @param groupIds the group IDs
1734            * @param classNameId the class name ID
1735            * @param start the lower bound of the range of d d m structures
1736            * @param end the upper bound of the range of d d m structures (not inclusive)
1737            * @return the range of matching d d m structures
1738            */
1739            public static List<DDMStructure> findByG_C(long[] groupIds,
1740                    long classNameId, int start, int end) {
1741                    return getPersistence().findByG_C(groupIds, classNameId, start, end);
1742            }
1743    
1744            /**
1745            * Returns an ordered range of all the d d m structures where groupId = any &#63; and classNameId = &#63;.
1746            *
1747            * <p>
1748            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1749            * </p>
1750            *
1751            * @param groupIds the group IDs
1752            * @param classNameId the class name ID
1753            * @param start the lower bound of the range of d d m structures
1754            * @param end the upper bound of the range of d d m structures (not inclusive)
1755            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1756            * @return the ordered range of matching d d m structures
1757            */
1758            public static List<DDMStructure> findByG_C(long[] groupIds,
1759                    long classNameId, int start, int end,
1760                    OrderByComparator<DDMStructure> orderByComparator) {
1761                    return getPersistence()
1762                                       .findByG_C(groupIds, classNameId, start, end,
1763                            orderByComparator);
1764            }
1765    
1766            /**
1767            * Removes all the d d m structures where groupId = &#63; and classNameId = &#63; from the database.
1768            *
1769            * @param groupId the group ID
1770            * @param classNameId the class name ID
1771            */
1772            public static void removeByG_C(long groupId, long classNameId) {
1773                    getPersistence().removeByG_C(groupId, classNameId);
1774            }
1775    
1776            /**
1777            * Returns the number of d d m structures where groupId = &#63; and classNameId = &#63;.
1778            *
1779            * @param groupId the group ID
1780            * @param classNameId the class name ID
1781            * @return the number of matching d d m structures
1782            */
1783            public static int countByG_C(long groupId, long classNameId) {
1784                    return getPersistence().countByG_C(groupId, classNameId);
1785            }
1786    
1787            /**
1788            * Returns the number of d d m structures where groupId = any &#63; and classNameId = &#63;.
1789            *
1790            * @param groupIds the group IDs
1791            * @param classNameId the class name ID
1792            * @return the number of matching d d m structures
1793            */
1794            public static int countByG_C(long[] groupIds, long classNameId) {
1795                    return getPersistence().countByG_C(groupIds, classNameId);
1796            }
1797    
1798            /**
1799            * Returns the number of d d m structures that the user has permission to view where groupId = &#63; and classNameId = &#63;.
1800            *
1801            * @param groupId the group ID
1802            * @param classNameId the class name ID
1803            * @return the number of matching d d m structures that the user has permission to view
1804            */
1805            public static int filterCountByG_C(long groupId, long classNameId) {
1806                    return getPersistence().filterCountByG_C(groupId, classNameId);
1807            }
1808    
1809            /**
1810            * Returns the number of d d m structures that the user has permission to view where groupId = any &#63; and classNameId = &#63;.
1811            *
1812            * @param groupIds the group IDs
1813            * @param classNameId the class name ID
1814            * @return the number of matching d d m structures that the user has permission to view
1815            */
1816            public static int filterCountByG_C(long[] groupIds, long classNameId) {
1817                    return getPersistence().filterCountByG_C(groupIds, classNameId);
1818            }
1819    
1820            /**
1821            * Returns all the d d m structures where companyId = &#63; and classNameId = &#63;.
1822            *
1823            * @param companyId the company ID
1824            * @param classNameId the class name ID
1825            * @return the matching d d m structures
1826            */
1827            public static List<DDMStructure> findByC_C(long companyId, long classNameId) {
1828                    return getPersistence().findByC_C(companyId, classNameId);
1829            }
1830    
1831            /**
1832            * Returns a range of all the d d m structures where companyId = &#63; and classNameId = &#63;.
1833            *
1834            * <p>
1835            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1836            * </p>
1837            *
1838            * @param companyId the company ID
1839            * @param classNameId the class name ID
1840            * @param start the lower bound of the range of d d m structures
1841            * @param end the upper bound of the range of d d m structures (not inclusive)
1842            * @return the range of matching d d m structures
1843            */
1844            public static List<DDMStructure> findByC_C(long companyId,
1845                    long classNameId, int start, int end) {
1846                    return getPersistence().findByC_C(companyId, classNameId, start, end);
1847            }
1848    
1849            /**
1850            * Returns an ordered range of all the d d m structures where companyId = &#63; and classNameId = &#63;.
1851            *
1852            * <p>
1853            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
1854            * </p>
1855            *
1856            * @param companyId the company ID
1857            * @param classNameId the class name ID
1858            * @param start the lower bound of the range of d d m structures
1859            * @param end the upper bound of the range of d d m structures (not inclusive)
1860            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1861            * @return the ordered range of matching d d m structures
1862            */
1863            public static List<DDMStructure> findByC_C(long companyId,
1864                    long classNameId, int start, int end,
1865                    OrderByComparator<DDMStructure> orderByComparator) {
1866                    return getPersistence()
1867                                       .findByC_C(companyId, classNameId, start, end,
1868                            orderByComparator);
1869            }
1870    
1871            /**
1872            * Returns the first d d m structure in the ordered set where companyId = &#63; and classNameId = &#63;.
1873            *
1874            * @param companyId the company ID
1875            * @param classNameId the class name ID
1876            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1877            * @return the first matching d d m structure
1878            * @throws NoSuchStructureException if a matching d d m structure could not be found
1879            */
1880            public static DDMStructure findByC_C_First(long companyId,
1881                    long classNameId, OrderByComparator<DDMStructure> orderByComparator)
1882                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1883                    return getPersistence()
1884                                       .findByC_C_First(companyId, classNameId, orderByComparator);
1885            }
1886    
1887            /**
1888            * Returns the first d d m structure in the ordered set where companyId = &#63; and classNameId = &#63;.
1889            *
1890            * @param companyId the company ID
1891            * @param classNameId the class name ID
1892            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1893            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1894            */
1895            public static DDMStructure fetchByC_C_First(long companyId,
1896                    long classNameId, OrderByComparator<DDMStructure> orderByComparator) {
1897                    return getPersistence()
1898                                       .fetchByC_C_First(companyId, classNameId, orderByComparator);
1899            }
1900    
1901            /**
1902            * Returns the last d d m structure in the ordered set where companyId = &#63; and classNameId = &#63;.
1903            *
1904            * @param companyId the company ID
1905            * @param classNameId the class name ID
1906            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1907            * @return the last matching d d m structure
1908            * @throws NoSuchStructureException if a matching d d m structure could not be found
1909            */
1910            public static DDMStructure findByC_C_Last(long companyId, long classNameId,
1911                    OrderByComparator<DDMStructure> orderByComparator)
1912                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1913                    return getPersistence()
1914                                       .findByC_C_Last(companyId, classNameId, orderByComparator);
1915            }
1916    
1917            /**
1918            * Returns the last d d m structure in the ordered set where companyId = &#63; and classNameId = &#63;.
1919            *
1920            * @param companyId the company ID
1921            * @param classNameId the class name ID
1922            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1923            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1924            */
1925            public static DDMStructure fetchByC_C_Last(long companyId,
1926                    long classNameId, OrderByComparator<DDMStructure> orderByComparator) {
1927                    return getPersistence()
1928                                       .fetchByC_C_Last(companyId, classNameId, orderByComparator);
1929            }
1930    
1931            /**
1932            * 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;.
1933            *
1934            * @param structureId the primary key of the current d d m structure
1935            * @param companyId the company ID
1936            * @param classNameId the class name ID
1937            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1938            * @return the previous, current, and next d d m structure
1939            * @throws NoSuchStructureException if a d d m structure with the primary key could not be found
1940            */
1941            public static DDMStructure[] findByC_C_PrevAndNext(long structureId,
1942                    long companyId, long classNameId,
1943                    OrderByComparator<DDMStructure> orderByComparator)
1944                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1945                    return getPersistence()
1946                                       .findByC_C_PrevAndNext(structureId, companyId, classNameId,
1947                            orderByComparator);
1948            }
1949    
1950            /**
1951            * Removes all the d d m structures where companyId = &#63; and classNameId = &#63; from the database.
1952            *
1953            * @param companyId the company ID
1954            * @param classNameId the class name ID
1955            */
1956            public static void removeByC_C(long companyId, long classNameId) {
1957                    getPersistence().removeByC_C(companyId, classNameId);
1958            }
1959    
1960            /**
1961            * Returns the number of d d m structures where companyId = &#63; and classNameId = &#63;.
1962            *
1963            * @param companyId the company ID
1964            * @param classNameId the class name ID
1965            * @return the number of matching d d m structures
1966            */
1967            public static int countByC_C(long companyId, long classNameId) {
1968                    return getPersistence().countByC_C(companyId, classNameId);
1969            }
1970    
1971            /**
1972            * Returns the d d m structure where groupId = &#63; and classNameId = &#63; and structureKey = &#63; or throws a {@link NoSuchStructureException} if it could not be found.
1973            *
1974            * @param groupId the group ID
1975            * @param classNameId the class name ID
1976            * @param structureKey the structure key
1977            * @return the matching d d m structure
1978            * @throws NoSuchStructureException if a matching d d m structure could not be found
1979            */
1980            public static DDMStructure findByG_C_S(long groupId, long classNameId,
1981                    java.lang.String structureKey)
1982                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1983                    return getPersistence().findByG_C_S(groupId, classNameId, structureKey);
1984            }
1985    
1986            /**
1987            * 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.
1988            *
1989            * @param groupId the group ID
1990            * @param classNameId the class name ID
1991            * @param structureKey the structure key
1992            * @return the matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1993            */
1994            public static DDMStructure fetchByG_C_S(long groupId, long classNameId,
1995                    java.lang.String structureKey) {
1996                    return getPersistence().fetchByG_C_S(groupId, classNameId, structureKey);
1997            }
1998    
1999            /**
2000            * 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.
2001            *
2002            * @param groupId the group ID
2003            * @param classNameId the class name ID
2004            * @param structureKey the structure key
2005            * @param retrieveFromCache whether to use the finder cache
2006            * @return the matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
2007            */
2008            public static DDMStructure fetchByG_C_S(long groupId, long classNameId,
2009                    java.lang.String structureKey, boolean retrieveFromCache) {
2010                    return getPersistence()
2011                                       .fetchByG_C_S(groupId, classNameId, structureKey,
2012                            retrieveFromCache);
2013            }
2014    
2015            /**
2016            * Removes the d d m structure where groupId = &#63; and classNameId = &#63; and structureKey = &#63; from the database.
2017            *
2018            * @param groupId the group ID
2019            * @param classNameId the class name ID
2020            * @param structureKey the structure key
2021            * @return the d d m structure that was removed
2022            */
2023            public static DDMStructure removeByG_C_S(long groupId, long classNameId,
2024                    java.lang.String structureKey)
2025                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
2026                    return getPersistence().removeByG_C_S(groupId, classNameId, structureKey);
2027            }
2028    
2029            /**
2030            * Returns the number of d d m structures where groupId = &#63; and classNameId = &#63; and structureKey = &#63;.
2031            *
2032            * @param groupId the group ID
2033            * @param classNameId the class name ID
2034            * @param structureKey the structure key
2035            * @return the number of matching d d m structures
2036            */
2037            public static int countByG_C_S(long groupId, long classNameId,
2038                    java.lang.String structureKey) {
2039                    return getPersistence().countByG_C_S(groupId, classNameId, structureKey);
2040            }
2041    
2042            /**
2043            * Returns all the d d m structures where groupId = &#63; and name = &#63; and description = &#63;.
2044            *
2045            * @param groupId the group ID
2046            * @param name the name
2047            * @param description the description
2048            * @return the matching d d m structures
2049            */
2050            public static List<DDMStructure> findByG_N_D(long groupId,
2051                    java.lang.String name, java.lang.String description) {
2052                    return getPersistence().findByG_N_D(groupId, name, description);
2053            }
2054    
2055            /**
2056            * Returns a range of all the d d m structures where groupId = &#63; and name = &#63; and description = &#63;.
2057            *
2058            * <p>
2059            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
2060            * </p>
2061            *
2062            * @param groupId the group ID
2063            * @param name the name
2064            * @param description the description
2065            * @param start the lower bound of the range of d d m structures
2066            * @param end the upper bound of the range of d d m structures (not inclusive)
2067            * @return the range of matching d d m structures
2068            */
2069            public static List<DDMStructure> findByG_N_D(long groupId,
2070                    java.lang.String name, java.lang.String description, int start, int end) {
2071                    return getPersistence()
2072                                       .findByG_N_D(groupId, name, description, start, end);
2073            }
2074    
2075            /**
2076            * Returns an ordered range of all the d d m structures where groupId = &#63; and name = &#63; and description = &#63;.
2077            *
2078            * <p>
2079            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
2080            * </p>
2081            *
2082            * @param groupId the group ID
2083            * @param name the name
2084            * @param description the description
2085            * @param start the lower bound of the range of d d m structures
2086            * @param end the upper bound of the range of d d m structures (not inclusive)
2087            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2088            * @return the ordered range of matching d d m structures
2089            */
2090            public static List<DDMStructure> findByG_N_D(long groupId,
2091                    java.lang.String name, java.lang.String description, int start,
2092                    int end, OrderByComparator<DDMStructure> orderByComparator) {
2093                    return getPersistence()
2094                                       .findByG_N_D(groupId, name, description, start, end,
2095                            orderByComparator);
2096            }
2097    
2098            /**
2099            * Returns the first d d m structure in the ordered set where groupId = &#63; and name = &#63; and description = &#63;.
2100            *
2101            * @param groupId the group ID
2102            * @param name the name
2103            * @param description the description
2104            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2105            * @return the first matching d d m structure
2106            * @throws NoSuchStructureException if a matching d d m structure could not be found
2107            */
2108            public static DDMStructure findByG_N_D_First(long groupId,
2109                    java.lang.String name, java.lang.String description,
2110                    OrderByComparator<DDMStructure> orderByComparator)
2111                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
2112                    return getPersistence()
2113                                       .findByG_N_D_First(groupId, name, description,
2114                            orderByComparator);
2115            }
2116    
2117            /**
2118            * Returns the first d d m structure in the ordered set where groupId = &#63; and name = &#63; and description = &#63;.
2119            *
2120            * @param groupId the group ID
2121            * @param name the name
2122            * @param description the description
2123            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2124            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
2125            */
2126            public static DDMStructure fetchByG_N_D_First(long groupId,
2127                    java.lang.String name, java.lang.String description,
2128                    OrderByComparator<DDMStructure> orderByComparator) {
2129                    return getPersistence()
2130                                       .fetchByG_N_D_First(groupId, name, description,
2131                            orderByComparator);
2132            }
2133    
2134            /**
2135            * Returns the last d d m structure in the ordered set where groupId = &#63; and name = &#63; and description = &#63;.
2136            *
2137            * @param groupId the group ID
2138            * @param name the name
2139            * @param description the description
2140            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2141            * @return the last matching d d m structure
2142            * @throws NoSuchStructureException if a matching d d m structure could not be found
2143            */
2144            public static DDMStructure findByG_N_D_Last(long groupId,
2145                    java.lang.String name, java.lang.String description,
2146                    OrderByComparator<DDMStructure> orderByComparator)
2147                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
2148                    return getPersistence()
2149                                       .findByG_N_D_Last(groupId, name, description,
2150                            orderByComparator);
2151            }
2152    
2153            /**
2154            * Returns the last d d m structure in the ordered set where groupId = &#63; and name = &#63; and description = &#63;.
2155            *
2156            * @param groupId the group ID
2157            * @param name the name
2158            * @param description the description
2159            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2160            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
2161            */
2162            public static DDMStructure fetchByG_N_D_Last(long groupId,
2163                    java.lang.String name, java.lang.String description,
2164                    OrderByComparator<DDMStructure> orderByComparator) {
2165                    return getPersistence()
2166                                       .fetchByG_N_D_Last(groupId, name, description,
2167                            orderByComparator);
2168            }
2169    
2170            /**
2171            * 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;.
2172            *
2173            * @param structureId the primary key of the current d d m structure
2174            * @param groupId the group ID
2175            * @param name the name
2176            * @param description the description
2177            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2178            * @return the previous, current, and next d d m structure
2179            * @throws NoSuchStructureException if a d d m structure with the primary key could not be found
2180            */
2181            public static DDMStructure[] findByG_N_D_PrevAndNext(long structureId,
2182                    long groupId, java.lang.String name, java.lang.String description,
2183                    OrderByComparator<DDMStructure> orderByComparator)
2184                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
2185                    return getPersistence()
2186                                       .findByG_N_D_PrevAndNext(structureId, groupId, name,
2187                            description, orderByComparator);
2188            }
2189    
2190            /**
2191            * Returns all the d d m structures that the user has permission to view where groupId = &#63; and name = &#63; and description = &#63;.
2192            *
2193            * @param groupId the group ID
2194            * @param name the name
2195            * @param description the description
2196            * @return the matching d d m structures that the user has permission to view
2197            */
2198            public static List<DDMStructure> filterFindByG_N_D(long groupId,
2199                    java.lang.String name, java.lang.String description) {
2200                    return getPersistence().filterFindByG_N_D(groupId, name, description);
2201            }
2202    
2203            /**
2204            * 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;.
2205            *
2206            * <p>
2207            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
2208            * </p>
2209            *
2210            * @param groupId the group ID
2211            * @param name the name
2212            * @param description the description
2213            * @param start the lower bound of the range of d d m structures
2214            * @param end the upper bound of the range of d d m structures (not inclusive)
2215            * @return the range of matching d d m structures that the user has permission to view
2216            */
2217            public static List<DDMStructure> filterFindByG_N_D(long groupId,
2218                    java.lang.String name, java.lang.String description, int start, int end) {
2219                    return getPersistence()
2220                                       .filterFindByG_N_D(groupId, name, description, start, end);
2221            }
2222    
2223            /**
2224            * 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;.
2225            *
2226            * <p>
2227            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
2228            * </p>
2229            *
2230            * @param groupId the group ID
2231            * @param name the name
2232            * @param description the description
2233            * @param start the lower bound of the range of d d m structures
2234            * @param end the upper bound of the range of d d m structures (not inclusive)
2235            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2236            * @return the ordered range of matching d d m structures that the user has permission to view
2237            */
2238            public static List<DDMStructure> filterFindByG_N_D(long groupId,
2239                    java.lang.String name, java.lang.String description, int start,
2240                    int end, OrderByComparator<DDMStructure> orderByComparator) {
2241                    return getPersistence()
2242                                       .filterFindByG_N_D(groupId, name, description, start, end,
2243                            orderByComparator);
2244            }
2245    
2246            /**
2247            * 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;.
2248            *
2249            * @param structureId the primary key of the current d d m structure
2250            * @param groupId the group ID
2251            * @param name the name
2252            * @param description the description
2253            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2254            * @return the previous, current, and next d d m structure
2255            * @throws NoSuchStructureException if a d d m structure with the primary key could not be found
2256            */
2257            public static DDMStructure[] filterFindByG_N_D_PrevAndNext(
2258                    long structureId, long groupId, java.lang.String name,
2259                    java.lang.String description,
2260                    OrderByComparator<DDMStructure> orderByComparator)
2261                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
2262                    return getPersistence()
2263                                       .filterFindByG_N_D_PrevAndNext(structureId, groupId, name,
2264                            description, orderByComparator);
2265            }
2266    
2267            /**
2268            * Removes all the d d m structures where groupId = &#63; and name = &#63; and description = &#63; from the database.
2269            *
2270            * @param groupId the group ID
2271            * @param name the name
2272            * @param description the description
2273            */
2274            public static void removeByG_N_D(long groupId, java.lang.String name,
2275                    java.lang.String description) {
2276                    getPersistence().removeByG_N_D(groupId, name, description);
2277            }
2278    
2279            /**
2280            * Returns the number of d d m structures where groupId = &#63; and name = &#63; and description = &#63;.
2281            *
2282            * @param groupId the group ID
2283            * @param name the name
2284            * @param description the description
2285            * @return the number of matching d d m structures
2286            */
2287            public static int countByG_N_D(long groupId, java.lang.String name,
2288                    java.lang.String description) {
2289                    return getPersistence().countByG_N_D(groupId, name, description);
2290            }
2291    
2292            /**
2293            * Returns the number of d d m structures that the user has permission to view where groupId = &#63; and name = &#63; and description = &#63;.
2294            *
2295            * @param groupId the group ID
2296            * @param name the name
2297            * @param description the description
2298            * @return the number of matching d d m structures that the user has permission to view
2299            */
2300            public static int filterCountByG_N_D(long groupId, java.lang.String name,
2301                    java.lang.String description) {
2302                    return getPersistence().filterCountByG_N_D(groupId, name, description);
2303            }
2304    
2305            /**
2306            * Caches the d d m structure in the entity cache if it is enabled.
2307            *
2308            * @param ddmStructure the d d m structure
2309            */
2310            public static void cacheResult(DDMStructure ddmStructure) {
2311                    getPersistence().cacheResult(ddmStructure);
2312            }
2313    
2314            /**
2315            * Caches the d d m structures in the entity cache if it is enabled.
2316            *
2317            * @param ddmStructures the d d m structures
2318            */
2319            public static void cacheResult(List<DDMStructure> ddmStructures) {
2320                    getPersistence().cacheResult(ddmStructures);
2321            }
2322    
2323            /**
2324            * Creates a new d d m structure with the primary key. Does not add the d d m structure to the database.
2325            *
2326            * @param structureId the primary key for the new d d m structure
2327            * @return the new d d m structure
2328            */
2329            public static DDMStructure create(long structureId) {
2330                    return getPersistence().create(structureId);
2331            }
2332    
2333            /**
2334            * Removes the d d m structure with the primary key from the database. Also notifies the appropriate model listeners.
2335            *
2336            * @param structureId the primary key of the d d m structure
2337            * @return the d d m structure that was removed
2338            * @throws NoSuchStructureException if a d d m structure with the primary key could not be found
2339            */
2340            public static DDMStructure remove(long structureId)
2341                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
2342                    return getPersistence().remove(structureId);
2343            }
2344    
2345            public static DDMStructure updateImpl(DDMStructure ddmStructure) {
2346                    return getPersistence().updateImpl(ddmStructure);
2347            }
2348    
2349            /**
2350            * Returns the d d m structure with the primary key or throws a {@link NoSuchStructureException} if it could not be found.
2351            *
2352            * @param structureId the primary key of the d d m structure
2353            * @return the d d m structure
2354            * @throws NoSuchStructureException if a d d m structure with the primary key could not be found
2355            */
2356            public static DDMStructure findByPrimaryKey(long structureId)
2357                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
2358                    return getPersistence().findByPrimaryKey(structureId);
2359            }
2360    
2361            /**
2362            * Returns the d d m structure with the primary key or returns <code>null</code> if it could not be found.
2363            *
2364            * @param structureId the primary key of the d d m structure
2365            * @return the d d m structure, or <code>null</code> if a d d m structure with the primary key could not be found
2366            */
2367            public static DDMStructure fetchByPrimaryKey(long structureId) {
2368                    return getPersistence().fetchByPrimaryKey(structureId);
2369            }
2370    
2371            public static java.util.Map<java.io.Serializable, DDMStructure> fetchByPrimaryKeys(
2372                    java.util.Set<java.io.Serializable> primaryKeys) {
2373                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
2374            }
2375    
2376            /**
2377            * Returns all the d d m structures.
2378            *
2379            * @return the d d m structures
2380            */
2381            public static List<DDMStructure> findAll() {
2382                    return getPersistence().findAll();
2383            }
2384    
2385            /**
2386            * Returns a range of all the d d m structures.
2387            *
2388            * <p>
2389            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
2390            * </p>
2391            *
2392            * @param start the lower bound of the range of d d m structures
2393            * @param end the upper bound of the range of d d m structures (not inclusive)
2394            * @return the range of d d m structures
2395            */
2396            public static List<DDMStructure> findAll(int start, int end) {
2397                    return getPersistence().findAll(start, end);
2398            }
2399    
2400            /**
2401            * Returns an ordered range of all the d d m structures.
2402            *
2403            * <p>
2404            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
2405            * </p>
2406            *
2407            * @param start the lower bound of the range of d d m structures
2408            * @param end the upper bound of the range of d d m structures (not inclusive)
2409            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2410            * @return the ordered range of d d m structures
2411            */
2412            public static List<DDMStructure> findAll(int start, int end,
2413                    OrderByComparator<DDMStructure> orderByComparator) {
2414                    return getPersistence().findAll(start, end, orderByComparator);
2415            }
2416    
2417            /**
2418            * Removes all the d d m structures from the database.
2419            */
2420            public static void removeAll() {
2421                    getPersistence().removeAll();
2422            }
2423    
2424            /**
2425            * Returns the number of d d m structures.
2426            *
2427            * @return the number of d d m structures
2428            */
2429            public static int countAll() {
2430                    return getPersistence().countAll();
2431            }
2432    
2433            /**
2434            * Returns the primaryKeys of document library file entry types associated with the d d m structure.
2435            *
2436            * @param pk the primary key of the d d m structure
2437            * @return long[] of the primaryKeys of document library file entry types associated with the d d m structure
2438            */
2439            public static long[] getDLFileEntryTypePrimaryKeys(long pk) {
2440                    return getPersistence().getDLFileEntryTypePrimaryKeys(pk);
2441            }
2442    
2443            /**
2444            * Returns all the document library file entry types associated with the d d m structure.
2445            *
2446            * @param pk the primary key of the d d m structure
2447            * @return the document library file entry types associated with the d d m structure
2448            */
2449            public static List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> getDLFileEntryTypes(
2450                    long pk) {
2451                    return getPersistence().getDLFileEntryTypes(pk);
2452            }
2453    
2454            /**
2455            * Returns a range of all the document library file entry types associated with the d d m structure.
2456            *
2457            * <p>
2458            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
2459            * </p>
2460            *
2461            * @param pk the primary key of the d d m structure
2462            * @param start the lower bound of the range of d d m structures
2463            * @param end the upper bound of the range of d d m structures (not inclusive)
2464            * @return the range of document library file entry types associated with the d d m structure
2465            */
2466            public static List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> getDLFileEntryTypes(
2467                    long pk, int start, int end) {
2468                    return getPersistence().getDLFileEntryTypes(pk, start, end);
2469            }
2470    
2471            /**
2472            * Returns an ordered range of all the document library file entry types associated with the d d m structure.
2473            *
2474            * <p>
2475            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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.
2476            * </p>
2477            *
2478            * @param pk the primary key of the d d m structure
2479            * @param start the lower bound of the range of d d m structures
2480            * @param end the upper bound of the range of d d m structures (not inclusive)
2481            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2482            * @return the ordered range of document library file entry types associated with the d d m structure
2483            */
2484            public static List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> getDLFileEntryTypes(
2485                    long pk, int start, int end,
2486                    OrderByComparator<com.liferay.portlet.documentlibrary.model.DLFileEntryType> orderByComparator) {
2487                    return getPersistence()
2488                                       .getDLFileEntryTypes(pk, start, end, orderByComparator);
2489            }
2490    
2491            /**
2492            * Returns the number of document library file entry types associated with the d d m structure.
2493            *
2494            * @param pk the primary key of the d d m structure
2495            * @return the number of document library file entry types associated with the d d m structure
2496            */
2497            public static int getDLFileEntryTypesSize(long pk) {
2498                    return getPersistence().getDLFileEntryTypesSize(pk);
2499            }
2500    
2501            /**
2502            * Returns <code>true</code> if the document library file entry type is associated with the d d m structure.
2503            *
2504            * @param pk the primary key of the d d m structure
2505            * @param dlFileEntryTypePK the primary key of the document library file entry type
2506            * @return <code>true</code> if the document library file entry type is associated with the d d m structure; <code>false</code> otherwise
2507            */
2508            public static boolean containsDLFileEntryType(long pk,
2509                    long dlFileEntryTypePK) {
2510                    return getPersistence().containsDLFileEntryType(pk, dlFileEntryTypePK);
2511            }
2512    
2513            /**
2514            * Returns <code>true</code> if the d d m structure has any document library file entry types associated with it.
2515            *
2516            * @param pk the primary key of the d d m structure to check for associations with document library file entry types
2517            * @return <code>true</code> if the d d m structure has any document library file entry types associated with it; <code>false</code> otherwise
2518            */
2519            public static boolean containsDLFileEntryTypes(long pk) {
2520                    return getPersistence().containsDLFileEntryTypes(pk);
2521            }
2522    
2523            /**
2524            * 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.
2525            *
2526            * @param pk the primary key of the d d m structure
2527            * @param dlFileEntryTypePK the primary key of the document library file entry type
2528            */
2529            public static void addDLFileEntryType(long pk, long dlFileEntryTypePK) {
2530                    getPersistence().addDLFileEntryType(pk, dlFileEntryTypePK);
2531            }
2532    
2533            /**
2534            * 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.
2535            *
2536            * @param pk the primary key of the d d m structure
2537            * @param dlFileEntryType the document library file entry type
2538            */
2539            public static void addDLFileEntryType(long pk,
2540                    com.liferay.portlet.documentlibrary.model.DLFileEntryType dlFileEntryType) {
2541                    getPersistence().addDLFileEntryType(pk, dlFileEntryType);
2542            }
2543    
2544            /**
2545            * 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.
2546            *
2547            * @param pk the primary key of the d d m structure
2548            * @param dlFileEntryTypePKs the primary keys of the document library file entry types
2549            */
2550            public static void addDLFileEntryTypes(long pk, long[] dlFileEntryTypePKs) {
2551                    getPersistence().addDLFileEntryTypes(pk, dlFileEntryTypePKs);
2552            }
2553    
2554            /**
2555            * 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.
2556            *
2557            * @param pk the primary key of the d d m structure
2558            * @param dlFileEntryTypes the document library file entry types
2559            */
2560            public static void addDLFileEntryTypes(long pk,
2561                    List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> dlFileEntryTypes) {
2562                    getPersistence().addDLFileEntryTypes(pk, dlFileEntryTypes);
2563            }
2564    
2565            /**
2566            * 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.
2567            *
2568            * @param pk the primary key of the d d m structure to clear the associated document library file entry types from
2569            */
2570            public static void clearDLFileEntryTypes(long pk) {
2571                    getPersistence().clearDLFileEntryTypes(pk);
2572            }
2573    
2574            /**
2575            * 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.
2576            *
2577            * @param pk the primary key of the d d m structure
2578            * @param dlFileEntryTypePK the primary key of the document library file entry type
2579            */
2580            public static void removeDLFileEntryType(long pk, long dlFileEntryTypePK) {
2581                    getPersistence().removeDLFileEntryType(pk, dlFileEntryTypePK);
2582            }
2583    
2584            /**
2585            * 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.
2586            *
2587            * @param pk the primary key of the d d m structure
2588            * @param dlFileEntryType the document library file entry type
2589            */
2590            public static void removeDLFileEntryType(long pk,
2591                    com.liferay.portlet.documentlibrary.model.DLFileEntryType dlFileEntryType) {
2592                    getPersistence().removeDLFileEntryType(pk, dlFileEntryType);
2593            }
2594    
2595            /**
2596            * 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.
2597            *
2598            * @param pk the primary key of the d d m structure
2599            * @param dlFileEntryTypePKs the primary keys of the document library file entry types
2600            */
2601            public static void removeDLFileEntryTypes(long pk, long[] dlFileEntryTypePKs) {
2602                    getPersistence().removeDLFileEntryTypes(pk, dlFileEntryTypePKs);
2603            }
2604    
2605            /**
2606            * 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.
2607            *
2608            * @param pk the primary key of the d d m structure
2609            * @param dlFileEntryTypes the document library file entry types
2610            */
2611            public static void removeDLFileEntryTypes(long pk,
2612                    List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> dlFileEntryTypes) {
2613                    getPersistence().removeDLFileEntryTypes(pk, dlFileEntryTypes);
2614            }
2615    
2616            /**
2617            * 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.
2618            *
2619            * @param pk the primary key of the d d m structure
2620            * @param dlFileEntryTypePKs the primary keys of the document library file entry types to be associated with the d d m structure
2621            */
2622            public static void setDLFileEntryTypes(long pk, long[] dlFileEntryTypePKs) {
2623                    getPersistence().setDLFileEntryTypes(pk, dlFileEntryTypePKs);
2624            }
2625    
2626            /**
2627            * 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.
2628            *
2629            * @param pk the primary key of the d d m structure
2630            * @param dlFileEntryTypes the document library file entry types to be associated with the d d m structure
2631            */
2632            public static void setDLFileEntryTypes(long pk,
2633                    List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> dlFileEntryTypes) {
2634                    getPersistence().setDLFileEntryTypes(pk, dlFileEntryTypes);
2635            }
2636    
2637            public static DDMStructurePersistence getPersistence() {
2638                    if (_persistence == null) {
2639                            _persistence = (DDMStructurePersistence)PortalBeanLocatorUtil.locate(DDMStructurePersistence.class.getName());
2640    
2641                            ReferenceRegistry.registerReference(DDMStructureUtil.class,
2642                                    "_persistence");
2643                    }
2644    
2645                    return _persistence;
2646            }
2647    
2648            /**
2649             * @deprecated As of 6.2.0
2650             */
2651            @Deprecated
2652            public void setPersistence(DDMStructurePersistence persistence) {
2653            }
2654    
2655            private static DDMStructurePersistence _persistence;
2656    }