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