Source code

001// --------------------------------------------------------------------------------
002// Copyright 2002-2026 Echo Three, LLC
003//
004// Licensed under the Apache License, Version 2.0 (the "License");
005// you may not use this file except in compliance with the License.
006// You may obtain a copy of the License at
007//
008//     http://www.apache.org/licenses/LICENSE-2.0
009//
010// Unless required by applicable law or agreed to in writing, software
011// distributed under the License is distributed on an "AS IS" BASIS,
012// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013// See the License for the specific language governing permissions and
014// limitations under the License.
015// --------------------------------------------------------------------------------
016// Generated File -- DO NOT EDIT BY HAND
017// --------------------------------------------------------------------------------
018
019/**
020 * PartyTrainingClassSessionStatusFactory.java
021 */
022
023package com.echothree.model.data.training.server.factory;
024
025import com.echothree.model.data.training.common.pk.PartyTrainingClassSessionPK;
026import com.echothree.model.data.training.common.pk.PartyTrainingClassSessionSectionPK;
027import com.echothree.model.data.training.common.pk.PartyTrainingClassSessionPagePK;
028import com.echothree.model.data.training.common.pk.PartyTrainingClassSessionQuestionPK;
029
030import com.echothree.model.data.training.server.entity.PartyTrainingClassSession;
031import com.echothree.model.data.training.server.entity.PartyTrainingClassSessionSection;
032import com.echothree.model.data.training.server.entity.PartyTrainingClassSessionPage;
033import com.echothree.model.data.training.server.entity.PartyTrainingClassSessionQuestion;
034
035import com.echothree.model.data.training.common.PartyTrainingClassSessionStatusConstants;
036import com.echothree.model.data.training.common.pk.PartyTrainingClassSessionStatusPK;
037import com.echothree.model.data.training.server.value.PartyTrainingClassSessionStatusValue;
038import com.echothree.model.data.training.server.entity.PartyTrainingClassSessionStatus;
039import com.echothree.util.common.exception.PersistenceDatabaseException;
040import com.echothree.util.common.exception.PersistenceDatabaseUpdateException;
041import com.echothree.util.common.exception.PersistenceNotNullException;
042import com.echothree.util.server.persistence.BaseFactory;
043import com.echothree.util.server.persistence.EntityIdGenerator;
044import com.echothree.util.server.persistence.EntityPermission;
045import com.echothree.util.server.persistence.PersistenceDebugFlags;
046import com.echothree.util.server.persistence.Session;
047import java.sql.PreparedStatement;
048import java.sql.ResultSet;
049import java.sql.SQLException;
050import java.sql.Types;
051import java.io.ByteArrayInputStream;
052import java.io.StringReader;
053import java.util.ArrayList;
054import java.util.Collection;
055import java.util.HashSet;
056import java.util.List;
057import java.util.Map;
058import java.util.Set;
059import javax.enterprise.context.ApplicationScoped;
060import javax.enterprise.inject.spi.CDI;
061import javax.inject.Inject;
062import org.jooq.ResultQuery;
063import org.slf4j.Logger;
064import org.slf4j.LoggerFactory;
065
066@ApplicationScoped
067public class PartyTrainingClassSessionStatusFactory
068        implements BaseFactory<PartyTrainingClassSessionStatusPK, PartyTrainingClassSessionStatus> {
069    
070    @Inject
071    Session session;
072    
073    //private static final Logger log = LoggerFactory.getLogger(PartyTrainingClassSessionStatusFactory.class);
074    
075    final private static String SQL_SELECT_READ_ONLY = "SELECT ptrnclssessst_partytrainingclasssessionstatusid, ptrnclssessst_ptrnclssess_partytrainingclasssessionid, ptrnclssessst_partytrainingclasssessionsectionsequence, ptrnclssessst_partytrainingclasssessionpagesequence, ptrnclssessst_lastpartytrainingclasssessionsectionid, ptrnclssessst_lastpartytrainingclasssessionpageid, ptrnclssessst_lastpartytrainingclasssessionquestionid FROM partytrainingclasssessionstatuses WHERE ptrnclssessst_partytrainingclasssessionstatusid = ?";
076    final private static String SQL_SELECT_READ_WRITE = "SELECT ptrnclssessst_partytrainingclasssessionstatusid, ptrnclssessst_ptrnclssess_partytrainingclasssessionid, ptrnclssessst_partytrainingclasssessionsectionsequence, ptrnclssessst_partytrainingclasssessionpagesequence, ptrnclssessst_lastpartytrainingclasssessionsectionid, ptrnclssessst_lastpartytrainingclasssessionpageid, ptrnclssessst_lastpartytrainingclasssessionquestionid FROM partytrainingclasssessionstatuses WHERE ptrnclssessst_partytrainingclasssessionstatusid = ? FOR UPDATE";
077    final private static String SQL_INSERT = "INSERT INTO partytrainingclasssessionstatuses (ptrnclssessst_partytrainingclasssessionstatusid, ptrnclssessst_ptrnclssess_partytrainingclasssessionid, ptrnclssessst_partytrainingclasssessionsectionsequence, ptrnclssessst_partytrainingclasssessionpagesequence, ptrnclssessst_lastpartytrainingclasssessionsectionid, ptrnclssessst_lastpartytrainingclasssessionpageid, ptrnclssessst_lastpartytrainingclasssessionquestionid) VALUES (?, ?, ?, ?, ?, ?, ?)";
078    final private static String SQL_UPDATE = "UPDATE partytrainingclasssessionstatuses SET ptrnclssessst_ptrnclssess_partytrainingclasssessionid = ?, ptrnclssessst_partytrainingclasssessionsectionsequence = ?, ptrnclssessst_partytrainingclasssessionpagesequence = ?, ptrnclssessst_lastpartytrainingclasssessionsectionid = ?, ptrnclssessst_lastpartytrainingclasssessionpageid = ?, ptrnclssessst_lastpartytrainingclasssessionquestionid = ? WHERE ptrnclssessst_partytrainingclasssessionstatusid = ?";
079    final private static String SQL_DELETE = "DELETE FROM partytrainingclasssessionstatuses WHERE ptrnclssessst_partytrainingclasssessionstatusid = ?";
080    final private static String SQL_VALID = "SELECT COUNT(*) FROM partytrainingclasssessionstatuses WHERE ptrnclssessst_partytrainingclasssessionstatusid = ?";
081    
082    final public static String PTRNCLSSESSST_PARTYTRAININGCLASSSESSIONSTATUSID = "ptrnclssessst_partytrainingclasssessionstatusid";
083    final public static String PTRNCLSSESSST_PTRNCLSSESS_PARTYTRAININGCLASSSESSIONID = "ptrnclssessst_ptrnclssess_partytrainingclasssessionid";
084    final public static String PTRNCLSSESSST_PARTYTRAININGCLASSSESSIONSECTIONSEQUENCE = "ptrnclssessst_partytrainingclasssessionsectionsequence";
085    final public static String PTRNCLSSESSST_PARTYTRAININGCLASSSESSIONPAGESEQUENCE = "ptrnclssessst_partytrainingclasssessionpagesequence";
086    final public static String PTRNCLSSESSST_LASTPARTYTRAININGCLASSSESSIONSECTIONID = "ptrnclssessst_lastpartytrainingclasssessionsectionid";
087    final public static String PTRNCLSSESSST_LASTPARTYTRAININGCLASSSESSIONPAGEID = "ptrnclssessst_lastpartytrainingclasssessionpageid";
088    final public static String PTRNCLSSESSST_LASTPARTYTRAININGCLASSSESSIONQUESTIONID = "ptrnclssessst_lastpartytrainingclasssessionquestionid";
089    
090    final private static EntityIdGenerator entityIdGenerator = new EntityIdGenerator(PartyTrainingClassSessionStatusConstants.COMPONENT_VENDOR_NAME, PartyTrainingClassSessionStatusConstants.ENTITY_TYPE_NAME);
091    
092    /** Creates a new instance of PartyTrainingClassSessionStatusFactory */
093    protected PartyTrainingClassSessionStatusFactory() {
094        super();
095    }
096    
097    public static PartyTrainingClassSessionStatusFactory getInstance() {
098        return CDI.current().select(PartyTrainingClassSessionStatusFactory.class).get();
099    }
100    
101    @Override
102    public String getComponentVendorName() {
103        return PartyTrainingClassSessionStatusConstants.COMPONENT_VENDOR_NAME;
104    }
105    
106    @Override
107    public String getEntityTypeName() {
108        return PartyTrainingClassSessionStatusConstants.ENTITY_TYPE_NAME;
109    }
110    
111    public PreparedStatement prepareStatement(String query) {
112        return session.prepareStatement(query);
113    }
114    
115    public PartyTrainingClassSessionStatusPK getNextPK() {
116        return new PartyTrainingClassSessionStatusPK(entityIdGenerator.getNextEntityId());
117    }
118    
119    public Set<PartyTrainingClassSessionStatusPK> getPKsFromResultSetAsSet(ResultSet rs)
120            throws PersistenceDatabaseException {
121        Set<PartyTrainingClassSessionStatusPK> _result = new HashSet<>();
122        
123        try {
124            while(rs.next()) {
125                _result.add(getPKFromResultSet(rs));
126            }
127        } catch (SQLException se) {
128            throw new PersistenceDatabaseException(se);
129        }
130        
131        return _result;
132    }
133    
134    public java.util.List<PartyTrainingClassSessionStatusPK> getPKsFromResultSetAsList(ResultSet rs)
135            throws PersistenceDatabaseException {
136        java.util.List<PartyTrainingClassSessionStatusPK> _result = new ArrayList<>();
137        
138        try {
139            while(rs.next()) {
140                _result.add(getPKFromResultSet(rs));
141            }
142        } catch (SQLException se) {
143            throw new PersistenceDatabaseException(se);
144        }
145        
146        return _result;
147    }
148    
149    public PartyTrainingClassSessionStatusPK getPKFromResultSet(ResultSet rs)
150            throws PersistenceDatabaseException {
151        PartyTrainingClassSessionStatusPK _result;
152        
153        try {
154            long ptrnclssessst_partytrainingclasssessionstatusid = rs.getLong(PTRNCLSSESSST_PARTYTRAININGCLASSSESSIONSTATUSID);
155            Long _entityId = rs.wasNull() ? null : ptrnclssessst_partytrainingclasssessionstatusid;
156            
157            _result = new PartyTrainingClassSessionStatusPK(_entityId);
158        } catch (SQLException se) {
159            throw new PersistenceDatabaseException(se);
160        }
161        
162        return _result;
163    }
164    
165    public java.util.List<PartyTrainingClassSessionStatusValue> getValuesFromPKs(Collection<PartyTrainingClassSessionStatusPK> pks)
166            throws PersistenceDatabaseException {
167        java.util.List<PartyTrainingClassSessionStatusValue> _values = new ArrayList<>(pks.size());
168        
169        for(PartyTrainingClassSessionStatusPK _pk: pks) {
170            _values.add(getValueFromPK(_pk));
171        }
172        
173        return _values;
174    }
175    
176    public PartyTrainingClassSessionStatusValue getValueFromPK(PartyTrainingClassSessionStatusPK pk)
177            throws PersistenceDatabaseException {
178        PartyTrainingClassSessionStatusValue _value;
179        
180        // See if we already have the entity in the session cache
181        PartyTrainingClassSessionStatus _entity = (PartyTrainingClassSessionStatus)session.getEntity(pk);
182        if(_entity == null)
183            _value = getEntityFromPK(EntityPermission.READ_ONLY, pk).getPartyTrainingClassSessionStatusValue();
184        else
185            _value = _entity.getPartyTrainingClassSessionStatusValue();
186        
187        return _value;
188    }
189    
190    public java.util.List<PartyTrainingClassSessionStatusValue> getValuesFromResultSet(ResultSet rs)
191            throws PersistenceDatabaseException {
192        java.util.List<PartyTrainingClassSessionStatusValue> _result = new ArrayList<>();
193        
194        try {
195            while(rs.next()) {
196                _result.add(getValueFromResultSet(rs));
197            }
198        } catch (SQLException se) {
199            throw new PersistenceDatabaseException(se);
200        }
201        
202        return _result;
203    }
204    
205    public PartyTrainingClassSessionStatusValue getValueFromResultSet(ResultSet rs)
206            throws PersistenceDatabaseException {
207        PartyTrainingClassSessionStatusValue _value;
208        
209        try {
210            Long ptrnclssessst_partytrainingclasssessionstatusid = rs.getLong(PTRNCLSSESSST_PARTYTRAININGCLASSSESSIONSTATUSID);
211            PartyTrainingClassSessionStatusPK _pk = new PartyTrainingClassSessionStatusPK(ptrnclssessst_partytrainingclasssessionstatusid);
212            
213            // See if we already have the entity in the session cache
214            PartyTrainingClassSessionStatus _entity = (PartyTrainingClassSessionStatus)session.getEntity(_pk);
215            
216            if(_entity == null) {
217                Long ptrnclssessst_ptrnclssess_partytrainingclasssessionid = rs.getLong(PTRNCLSSESSST_PTRNCLSSESS_PARTYTRAININGCLASSSESSIONID);
218                if(rs.wasNull())
219                    ptrnclssessst_ptrnclssess_partytrainingclasssessionid = null;
220                
221                Integer ptrnclssessst_partytrainingclasssessionsectionsequence = rs.getInt(PTRNCLSSESSST_PARTYTRAININGCLASSSESSIONSECTIONSEQUENCE);
222                if(rs.wasNull())
223                    ptrnclssessst_partytrainingclasssessionsectionsequence = null;
224                
225                Integer ptrnclssessst_partytrainingclasssessionpagesequence = rs.getInt(PTRNCLSSESSST_PARTYTRAININGCLASSSESSIONPAGESEQUENCE);
226                if(rs.wasNull())
227                    ptrnclssessst_partytrainingclasssessionpagesequence = null;
228                
229                Long ptrnclssessst_lastpartytrainingclasssessionsectionid = rs.getLong(PTRNCLSSESSST_LASTPARTYTRAININGCLASSSESSIONSECTIONID);
230                if(rs.wasNull())
231                    ptrnclssessst_lastpartytrainingclasssessionsectionid = null;
232                
233                Long ptrnclssessst_lastpartytrainingclasssessionpageid = rs.getLong(PTRNCLSSESSST_LASTPARTYTRAININGCLASSSESSIONPAGEID);
234                if(rs.wasNull())
235                    ptrnclssessst_lastpartytrainingclasssessionpageid = null;
236                
237                Long ptrnclssessst_lastpartytrainingclasssessionquestionid = rs.getLong(PTRNCLSSESSST_LASTPARTYTRAININGCLASSSESSIONQUESTIONID);
238                if(rs.wasNull())
239                    ptrnclssessst_lastpartytrainingclasssessionquestionid = null;
240                
241                _value = new PartyTrainingClassSessionStatusValue(_pk, new PartyTrainingClassSessionPK(ptrnclssessst_ptrnclssess_partytrainingclasssessionid), ptrnclssessst_partytrainingclasssessionsectionsequence, ptrnclssessst_partytrainingclasssessionpagesequence, new PartyTrainingClassSessionSectionPK(ptrnclssessst_lastpartytrainingclasssessionsectionid), new PartyTrainingClassSessionPagePK(ptrnclssessst_lastpartytrainingclasssessionpageid), new PartyTrainingClassSessionQuestionPK(ptrnclssessst_lastpartytrainingclasssessionquestionid));
242            } else
243                _value = _entity.getPartyTrainingClassSessionStatusValue();
244        } catch (SQLException se) {
245            throw new PersistenceDatabaseException(se);
246        }
247        
248        return _value;
249    }
250    
251    public java.util.List<PartyTrainingClassSessionStatus> getEntitiesFromPKs(EntityPermission entityPermission, Collection<PartyTrainingClassSessionStatusPK> pks)
252            throws PersistenceDatabaseException {
253        java.util.List<PartyTrainingClassSessionStatus> _entities = new ArrayList<>(pks.size());
254        
255        for(PartyTrainingClassSessionStatusPK _pk: pks) {
256            _entities.add(getEntityFromPK(entityPermission, _pk));
257        }
258        
259        return _entities;
260    }
261    
262    public PartyTrainingClassSessionStatus getEntityFromValue(EntityPermission entityPermission, PartyTrainingClassSessionStatusValue value) {
263        return getEntityFromPK(entityPermission, value.getPrimaryKey());
264    }
265    
266    public PartyTrainingClassSessionStatus getEntityFromCache(PartyTrainingClassSessionStatusPK pk) {
267        PartyTrainingClassSessionStatusValue _value = (PartyTrainingClassSessionStatusValue)session.getValueCache().get(pk);
268    
269        return _value == null ? null : new PartyTrainingClassSessionStatus(_value, EntityPermission.READ_ONLY);
270    }
271    
272    public PartyTrainingClassSessionStatus getEntityFromPK(EntityPermission entityPermission, PartyTrainingClassSessionStatusPK pk)
273            throws PersistenceDatabaseException {
274        PartyTrainingClassSessionStatus _entity;
275        
276        // See if we already have the entity in the session cache
277        _entity = (PartyTrainingClassSessionStatus)session.getEntity(pk);
278        if(_entity != null) {
279            // If the requested permission is READ_WRITE, and the cached permission is
280            // READ_ONLY, then pretend that the cached object wasn't found, and create
281            // a new entity that is READ_WRITE.
282            if(entityPermission.equals(EntityPermission.READ_WRITE)) {
283                if(_entity.getEntityPermission().equals(EntityPermission.READ_ONLY))
284                    _entity = null;
285            }
286        }
287        
288        if(_entity == null && entityPermission.equals(EntityPermission.READ_ONLY)) {
289            _entity = getEntityFromCache(pk);
290        }
291        
292        if(_entity == null) {
293            PreparedStatement _ps = session.prepareStatement(entityPermission.equals(EntityPermission.READ_ONLY)? SQL_SELECT_READ_ONLY: SQL_SELECT_READ_WRITE);
294            long _entityId = pk.getEntityId();
295            ResultSet _rs = null;
296            
297            try {
298                _ps.setLong(1, _entityId);
299                _rs = _ps.executeQuery();
300                if(_rs.next()) {
301                    _entity = getEntityFromResultSet(entityPermission, _rs);
302                }
303            } catch (SQLException se) {
304                throw new PersistenceDatabaseException(se);
305            } finally {
306                if(_rs != null) {
307                    try {
308                        _rs.close();
309                    } catch (SQLException se) {
310                        // do nothing
311                    }
312                }
313            }
314        }
315        
316        return _entity;
317    }
318    
319    public Set<PartyTrainingClassSessionStatusPK> getPKsFromQueryAsSet(PreparedStatement ps, final Object... params)
320            throws PersistenceDatabaseException {
321        Set<PartyTrainingClassSessionStatusPK> _pks;
322        ResultSet _rs = null;
323        
324        try {
325            if(params.length != 0) {
326                Session.setQueryParams(ps, params);
327            }
328            
329            _rs = ps.executeQuery();
330            _pks = getPKsFromResultSetAsSet(_rs);
331            _rs.close();
332        } catch (SQLException se) {
333            throw new PersistenceDatabaseException(se);
334        } finally {
335            if(_rs != null) {
336                try {
337                    _rs.close();
338                } catch (SQLException se) {
339                    // do nothing
340                }
341            }
342        }
343        
344        return _pks;
345    }
346    
347    public java.util.List<PartyTrainingClassSessionStatusPK> getPKsFromQueryAsList(PreparedStatement ps, final Object... params)
348            throws PersistenceDatabaseException {
349        java.util.List<PartyTrainingClassSessionStatusPK> _pks;
350        ResultSet _rs = null;
351        
352        try {
353            if(params.length != 0) {
354                Session.setQueryParams(ps, params);
355            }
356            
357            _rs = ps.executeQuery();
358            _pks = getPKsFromResultSetAsList(_rs);
359            _rs.close();
360        } catch (SQLException se) {
361            throw new PersistenceDatabaseException(se);
362        } finally {
363            if(_rs != null) {
364                try {
365                    _rs.close();
366                } catch (SQLException se) {
367                    // do nothing
368                }
369            }
370        }
371        
372        return _pks;
373    }
374    
375    public PartyTrainingClassSessionStatusPK getPKFromQuery(PreparedStatement ps, final Object... params)
376            throws PersistenceDatabaseException {
377        PartyTrainingClassSessionStatusPK _pk = null;
378        ResultSet _rs = null;
379        
380        try {
381            if(params.length != 0) {
382                Session.setQueryParams(ps, params);
383            }
384            
385            _rs = ps.executeQuery();
386            if(_rs.next()) {
387                _pk = getPKFromResultSet(_rs);
388            }
389            _rs.close();
390        } catch (SQLException se) {
391            throw new PersistenceDatabaseException(se);
392        } finally {
393            if(_rs != null) {
394                try {
395                    _rs.close();
396                } catch (SQLException se) {
397                    // do nothing
398                }
399            }
400        }
401        
402        return _pk;
403    }
404    
405    public java.util.List<PartyTrainingClassSessionStatus> getEntitiesFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap, final Object... params)
406            throws PersistenceDatabaseException {
407        PreparedStatement ps = session.prepareStatement(queryMap.get(entityPermission));
408        
409        return getEntitiesFromQuery(entityPermission, ps, params);
410    }
411    
412    public java.util.List<PartyTrainingClassSessionStatus> getEntitiesFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap)
413            throws PersistenceDatabaseException {
414        PreparedStatement ps = session.prepareStatement(queryMap.get(entityPermission));
415        
416        return getEntitiesFromQuery(entityPermission, ps);
417    }
418    
419    public java.util.List<PartyTrainingClassSessionStatus> getEntitiesFromQuery(EntityPermission entityPermission, ResultQuery<?> query)
420            throws PersistenceDatabaseException {
421        PreparedStatement ps = session.prepareStatement(query.getSQL());
422        
423        return getEntitiesFromQuery(entityPermission, ps, query.getBindValues().toArray());
424    }
425    
426    public java.util.List<PartyTrainingClassSessionStatus> getEntitiesFromQuery(EntityPermission entityPermission, PreparedStatement ps, final Object... params)
427            throws PersistenceDatabaseException {
428        java.util.List<PartyTrainingClassSessionStatus> _entities;
429        ResultSet _rs = null;
430        
431        try {
432            if(params.length != 0) {
433                Session.setQueryParams(ps, params);
434            }
435            
436            _rs = ps.executeQuery();
437            _entities = getEntitiesFromResultSet(entityPermission, _rs);
438            _rs.close();
439        } catch (SQLException se) {
440            throw new PersistenceDatabaseException(se);
441        } finally {
442            if(_rs != null) {
443                try {
444                    _rs.close();
445                } catch (SQLException se) {
446                    // do nothing
447                }
448            }
449        }
450        
451        return _entities;
452    }
453    
454    public PartyTrainingClassSessionStatus getEntityFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap, final Object... params)
455            throws PersistenceDatabaseException {
456        PreparedStatement ps = session.prepareStatement(queryMap.get(entityPermission));
457        
458        return getEntityFromQuery(entityPermission, ps, params);
459    }
460    
461    public PartyTrainingClassSessionStatus getEntityFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap)
462            throws PersistenceDatabaseException {
463        PreparedStatement ps = session.prepareStatement(queryMap.get(entityPermission));
464        
465        return getEntityFromQuery(entityPermission, ps);
466    }
467    
468    public PartyTrainingClassSessionStatus getEntityFromQuery(EntityPermission entityPermission, ResultQuery<?> query)
469            throws PersistenceDatabaseException {
470        PreparedStatement ps = session.prepareStatement(query.getSQL());
471        
472        return getEntityFromQuery(entityPermission, ps, query.getBindValues().toArray());
473    }
474    
475    public PartyTrainingClassSessionStatus getEntityFromQuery(EntityPermission entityPermission, PreparedStatement ps, final Object... params)
476            throws PersistenceDatabaseException {
477        PartyTrainingClassSessionStatus _entity = null;
478        ResultSet _rs = null;
479        
480        try {
481            if(params.length != 0) {
482                Session.setQueryParams(ps, params);
483            }
484            
485            _rs = ps.executeQuery();
486            if(_rs.next()) {
487                _entity = getEntityFromResultSet(entityPermission, _rs);
488            }
489            _rs.close();
490        } catch (SQLException se) {
491            throw new PersistenceDatabaseException(se);
492        } finally {
493            if(_rs != null) {
494                try {
495                    _rs.close();
496                } catch (SQLException se) {
497                    // do nothing
498                }
499            }
500        }
501        
502        return _entity;
503    }
504    
505    public java.util.List<PartyTrainingClassSessionStatus> getEntitiesFromResultSet(EntityPermission entityPermission, ResultSet rs)
506            throws PersistenceDatabaseException {
507        java.util.List<PartyTrainingClassSessionStatus> _result = new ArrayList<>();
508        
509        try {
510            while(rs.next()) {
511                _result.add(getEntityFromResultSet(entityPermission, rs));
512            }
513        } catch (SQLException se) {
514            throw new PersistenceDatabaseException(se);
515        }
516        
517        return _result;
518    }
519    
520    public PartyTrainingClassSessionStatus getEntityFromResultSet(EntityPermission entityPermission, ResultSet rs)
521            throws PersistenceDatabaseException {
522        PartyTrainingClassSessionStatus _entity;
523        
524        try {
525            Long ptrnclssessst_partytrainingclasssessionstatusid = rs.getLong(PTRNCLSSESSST_PARTYTRAININGCLASSSESSIONSTATUSID);
526            PartyTrainingClassSessionStatusPK _pk = new PartyTrainingClassSessionStatusPK(ptrnclssessst_partytrainingclasssessionstatusid);
527            
528            // See if we already have the entity in the session cache
529            _entity = (PartyTrainingClassSessionStatus)session.getEntity(_pk);
530            if(_entity != null) {
531                // If the requested permission is READ_WRITE, and the cached permission is
532                // READ_ONLY, then pretend that the cached object wasn't found, and create
533                // a new entity that is READ_WRITE.
534                if(entityPermission.equals(EntityPermission.READ_WRITE)) {
535                    if(_entity.getEntityPermission().equals(EntityPermission.READ_ONLY))
536                        _entity = null;
537                }
538            }
539            boolean foundInSessionCache = _entity != null;
540            
541            if(_entity == null && entityPermission.equals(EntityPermission.READ_ONLY)) {
542                _entity = getEntityFromCache(_pk);
543            }
544            
545            if(_entity == null) {
546                Long ptrnclssessst_ptrnclssess_partytrainingclasssessionid = rs.getLong(PTRNCLSSESSST_PTRNCLSSESS_PARTYTRAININGCLASSSESSIONID);
547                if(rs.wasNull())
548                    ptrnclssessst_ptrnclssess_partytrainingclasssessionid = null;
549                
550                Integer ptrnclssessst_partytrainingclasssessionsectionsequence = rs.getInt(PTRNCLSSESSST_PARTYTRAININGCLASSSESSIONSECTIONSEQUENCE);
551                if(rs.wasNull())
552                    ptrnclssessst_partytrainingclasssessionsectionsequence = null;
553                
554                Integer ptrnclssessst_partytrainingclasssessionpagesequence = rs.getInt(PTRNCLSSESSST_PARTYTRAININGCLASSSESSIONPAGESEQUENCE);
555                if(rs.wasNull())
556                    ptrnclssessst_partytrainingclasssessionpagesequence = null;
557                
558                Long ptrnclssessst_lastpartytrainingclasssessionsectionid = rs.getLong(PTRNCLSSESSST_LASTPARTYTRAININGCLASSSESSIONSECTIONID);
559                if(rs.wasNull())
560                    ptrnclssessst_lastpartytrainingclasssessionsectionid = null;
561                
562                Long ptrnclssessst_lastpartytrainingclasssessionpageid = rs.getLong(PTRNCLSSESSST_LASTPARTYTRAININGCLASSSESSIONPAGEID);
563                if(rs.wasNull())
564                    ptrnclssessst_lastpartytrainingclasssessionpageid = null;
565                
566                Long ptrnclssessst_lastpartytrainingclasssessionquestionid = rs.getLong(PTRNCLSSESSST_LASTPARTYTRAININGCLASSSESSIONQUESTIONID);
567                if(rs.wasNull())
568                    ptrnclssessst_lastpartytrainingclasssessionquestionid = null;
569                
570                PartyTrainingClassSessionStatusValue _value = new PartyTrainingClassSessionStatusValue(_pk, ptrnclssessst_ptrnclssess_partytrainingclasssessionid == null? null: new PartyTrainingClassSessionPK(ptrnclssessst_ptrnclssess_partytrainingclasssessionid), ptrnclssessst_partytrainingclasssessionsectionsequence, ptrnclssessst_partytrainingclasssessionpagesequence, ptrnclssessst_lastpartytrainingclasssessionsectionid == null? null: new PartyTrainingClassSessionSectionPK(ptrnclssessst_lastpartytrainingclasssessionsectionid), ptrnclssessst_lastpartytrainingclasssessionpageid == null? null: new PartyTrainingClassSessionPagePK(ptrnclssessst_lastpartytrainingclasssessionpageid), ptrnclssessst_lastpartytrainingclasssessionquestionid == null? null: new PartyTrainingClassSessionQuestionPK(ptrnclssessst_lastpartytrainingclasssessionquestionid));
571                _entity = new PartyTrainingClassSessionStatus(_value, entityPermission);
572            }
573            
574            if(!foundInSessionCache) {
575                if(entityPermission.equals(EntityPermission.READ_ONLY)) {
576                    session.putReadOnlyEntity(_pk, _entity);
577                    session.getValueCache().put(_entity.getPartyTrainingClassSessionStatusValue());
578                } else {
579                    session.putReadWriteEntity(_pk, _entity);
580                }
581            }
582        } catch (SQLException se) {
583            throw new PersistenceDatabaseException(se);
584        }
585        
586        return _entity;
587    }
588    
589    public PartyTrainingClassSessionStatus create(PartyTrainingClassSession partyTrainingClassSession, Integer partyTrainingClassSessionSectionSequence, Integer partyTrainingClassSessionPageSequence, PartyTrainingClassSessionSection lastPartyTrainingClassSessionSection, PartyTrainingClassSessionPage lastPartyTrainingClassSessionPage, PartyTrainingClassSessionQuestion lastPartyTrainingClassSessionQuestion)
590            throws PersistenceDatabaseException, PersistenceNotNullException {
591        return create(partyTrainingClassSession == null ? null : partyTrainingClassSession.getPrimaryKey(), partyTrainingClassSessionSectionSequence, partyTrainingClassSessionPageSequence, lastPartyTrainingClassSessionSection == null ? null : lastPartyTrainingClassSessionSection.getPrimaryKey(), lastPartyTrainingClassSessionPage == null ? null : lastPartyTrainingClassSessionPage.getPrimaryKey(), lastPartyTrainingClassSessionQuestion == null ? null : lastPartyTrainingClassSessionQuestion.getPrimaryKey());
592    }
593    
594    private void bindForCreate(PreparedStatement _ps, PartyTrainingClassSessionStatusValue _value)
595            throws SQLException {
596        _ps.setLong(1, _value.getEntityId());
597        
598        PartyTrainingClassSessionPK ptrnclssessst_ptrnclssess_partytrainingclasssessionid = _value.getPartyTrainingClassSessionPK();
599        if(ptrnclssessst_ptrnclssess_partytrainingclasssessionid == null)
600            _ps.setNull(2, Types.BIGINT);
601        else
602            _ps.setLong(2, ptrnclssessst_ptrnclssess_partytrainingclasssessionid.getEntityId());
603            
604        Integer ptrnclssessst_partytrainingclasssessionsectionsequence = _value.getPartyTrainingClassSessionSectionSequence();
605        if(ptrnclssessst_partytrainingclasssessionsectionsequence == null)
606            _ps.setNull(3, Types.INTEGER);
607        else
608            _ps.setInt(3, ptrnclssessst_partytrainingclasssessionsectionsequence);
609            
610        Integer ptrnclssessst_partytrainingclasssessionpagesequence = _value.getPartyTrainingClassSessionPageSequence();
611        if(ptrnclssessst_partytrainingclasssessionpagesequence == null)
612            _ps.setNull(4, Types.INTEGER);
613        else
614            _ps.setInt(4, ptrnclssessst_partytrainingclasssessionpagesequence);
615            
616        PartyTrainingClassSessionSectionPK ptrnclssessst_lastpartytrainingclasssessionsectionid = _value.getLastPartyTrainingClassSessionSectionPK();
617        if(ptrnclssessst_lastpartytrainingclasssessionsectionid == null)
618            _ps.setNull(5, Types.BIGINT);
619        else
620            _ps.setLong(5, ptrnclssessst_lastpartytrainingclasssessionsectionid.getEntityId());
621            
622        PartyTrainingClassSessionPagePK ptrnclssessst_lastpartytrainingclasssessionpageid = _value.getLastPartyTrainingClassSessionPagePK();
623        if(ptrnclssessst_lastpartytrainingclasssessionpageid == null)
624            _ps.setNull(6, Types.BIGINT);
625        else
626            _ps.setLong(6, ptrnclssessst_lastpartytrainingclasssessionpageid.getEntityId());
627            
628        PartyTrainingClassSessionQuestionPK ptrnclssessst_lastpartytrainingclasssessionquestionid = _value.getLastPartyTrainingClassSessionQuestionPK();
629        if(ptrnclssessst_lastpartytrainingclasssessionquestionid == null)
630            _ps.setNull(7, Types.BIGINT);
631        else
632            _ps.setLong(7, ptrnclssessst_lastpartytrainingclasssessionquestionid.getEntityId());
633            
634    }
635    
636    public PartyTrainingClassSessionStatus create(PartyTrainingClassSessionPK partyTrainingClassSessionPK, Integer partyTrainingClassSessionSectionSequence, Integer partyTrainingClassSessionPageSequence, PartyTrainingClassSessionSectionPK lastPartyTrainingClassSessionSectionPK, PartyTrainingClassSessionPagePK lastPartyTrainingClassSessionPagePK, PartyTrainingClassSessionQuestionPK lastPartyTrainingClassSessionQuestionPK)
637            throws PersistenceDatabaseException, PersistenceNotNullException {
638        PartyTrainingClassSessionStatusPK _pk = getNextPK();
639        PartyTrainingClassSessionStatusValue _value = new PartyTrainingClassSessionStatusValue(_pk, partyTrainingClassSessionPK, partyTrainingClassSessionSectionSequence, partyTrainingClassSessionPageSequence, lastPartyTrainingClassSessionSectionPK, lastPartyTrainingClassSessionPagePK, lastPartyTrainingClassSessionQuestionPK);
640        
641        PreparedStatement _ps = session.prepareStatement(SQL_INSERT);
642        
643        try {
644            bindForCreate(_ps, _value);
645            
646            if(PersistenceDebugFlags.CheckEntityInsertRowCount) {
647                int _count = _ps.executeUpdate();
648                
649                if(_count != 1) {
650                    throw new PersistenceDatabaseUpdateException("insert failed, _count = " + _count);
651                }
652            } else {
653                 _ps.executeUpdate();
654            }
655            
656            session.getValueCache().put(_value);
657        } catch (SQLException se) {
658            throw new PersistenceDatabaseException(se);
659        }
660        
661        PartyTrainingClassSessionStatus _entity = new PartyTrainingClassSessionStatus(_value, EntityPermission.READ_ONLY);
662        session.putReadOnlyEntity(_pk, _entity);
663        
664        return _entity;
665    }
666    
667    public void create(Collection<PartyTrainingClassSessionStatusValue> _values)
668            throws PersistenceDatabaseException, PersistenceNotNullException {
669        int _size = _values.size();
670        
671        if(_size > 0) {
672            PreparedStatement _ps = session.prepareStatement(SQL_INSERT);
673            List<PartyTrainingClassSessionStatusValue> _cacheValues = new ArrayList<>(_size);
674            
675            try {
676                for(PartyTrainingClassSessionStatusValue _value : _values) {
677                    _value.setEntityId(entityIdGenerator.getNextEntityId());
678                    bindForCreate(_ps, _value);
679                    
680                    _ps.addBatch();
681                    
682                    _cacheValues.add(_value);
683                }
684                
685                if(PersistenceDebugFlags.CheckEntityInsertRowCount) {
686                    int[] _counts = _ps.executeBatch();
687                    
688                    for(int _countOffset = 0 ; _countOffset < _size ; _countOffset++) {
689                        if(_counts[_countOffset] != 1 && _counts[_countOffset] != PreparedStatement.SUCCESS_NO_INFO) {
690                            throw new PersistenceDatabaseUpdateException("batch insert failed, _counts[" + _countOffset + "] = " + _counts[_countOffset]);
691                        }
692                    }
693                } else {
694                     _ps.executeBatch();
695                }
696                
697                _ps.clearBatch();
698            } catch (SQLException se) {
699                throw new PersistenceDatabaseException(se);
700            }
701            
702            _cacheValues.forEach((_cacheValue) -> {
703                PartyTrainingClassSessionStatus _cacheEntity = new PartyTrainingClassSessionStatus(_cacheValue, EntityPermission.READ_ONLY);
704                
705                session.putReadOnlyEntity(_cacheValue.getPrimaryKey(), _cacheEntity);
706            });
707        }
708    }
709    
710    private boolean bindForStore(PreparedStatement _ps, PartyTrainingClassSessionStatusValue _value)
711            throws SQLException {
712        boolean _hasBeenModified = _value.hasBeenModified();
713        
714        if(_hasBeenModified) {
715            PartyTrainingClassSessionPK ptrnclssessst_ptrnclssess_partytrainingclasssessionid = _value.getPartyTrainingClassSessionPK();
716            if(ptrnclssessst_ptrnclssess_partytrainingclasssessionid == null)
717                _ps.setNull(1, Types.BIGINT);
718            else
719                _ps.setLong(1, ptrnclssessst_ptrnclssess_partytrainingclasssessionid.getEntityId());
720            
721            Integer ptrnclssessst_partytrainingclasssessionsectionsequence = _value.getPartyTrainingClassSessionSectionSequence();
722            if(ptrnclssessst_partytrainingclasssessionsectionsequence == null)
723                _ps.setNull(2, Types.INTEGER);
724            else
725                _ps.setInt(2, ptrnclssessst_partytrainingclasssessionsectionsequence);
726            
727            Integer ptrnclssessst_partytrainingclasssessionpagesequence = _value.getPartyTrainingClassSessionPageSequence();
728            if(ptrnclssessst_partytrainingclasssessionpagesequence == null)
729                _ps.setNull(3, Types.INTEGER);
730            else
731                _ps.setInt(3, ptrnclssessst_partytrainingclasssessionpagesequence);
732            
733            PartyTrainingClassSessionSectionPK ptrnclssessst_lastpartytrainingclasssessionsectionid = _value.getLastPartyTrainingClassSessionSectionPK();
734            if(ptrnclssessst_lastpartytrainingclasssessionsectionid == null)
735                _ps.setNull(4, Types.BIGINT);
736            else
737                _ps.setLong(4, ptrnclssessst_lastpartytrainingclasssessionsectionid.getEntityId());
738            
739            PartyTrainingClassSessionPagePK ptrnclssessst_lastpartytrainingclasssessionpageid = _value.getLastPartyTrainingClassSessionPagePK();
740            if(ptrnclssessst_lastpartytrainingclasssessionpageid == null)
741                _ps.setNull(5, Types.BIGINT);
742            else
743                _ps.setLong(5, ptrnclssessst_lastpartytrainingclasssessionpageid.getEntityId());
744            
745            PartyTrainingClassSessionQuestionPK ptrnclssessst_lastpartytrainingclasssessionquestionid = _value.getLastPartyTrainingClassSessionQuestionPK();
746            if(ptrnclssessst_lastpartytrainingclasssessionquestionid == null)
747                _ps.setNull(6, Types.BIGINT);
748            else
749                _ps.setLong(6, ptrnclssessst_lastpartytrainingclasssessionquestionid.getEntityId());
750            
751            _ps.setLong(7, _value.getPrimaryKey().getEntityId());
752            
753            _value.clearHasBeenModified();
754        }
755        
756        return _hasBeenModified;
757    }
758    
759    @Override
760    public void store(PartyTrainingClassSessionStatus entity)
761            throws PersistenceDatabaseException {
762        PreparedStatement _ps = session.prepareStatement(SQL_UPDATE);
763        
764        try {
765            PartyTrainingClassSessionStatusValue _value = entity.getPartyTrainingClassSessionStatusValue();
766            
767            if(bindForStore(_ps, _value)) {
768                if(PersistenceDebugFlags.CheckEntityUpdateRowCount) {
769                    int _count = _ps.executeUpdate();
770                    
771                    if(_count != 1) {
772                        throw new PersistenceDatabaseUpdateException("update failed, _count = " + _count);
773                    }
774                } else {
775                     _ps.executeUpdate();
776                }
777                
778                session.getValueCache().put(_value);
779            }
780        } catch (SQLException se) {
781            throw new PersistenceDatabaseException(se);
782        }
783    }
784    
785    @Override
786    public void store(Collection<PartyTrainingClassSessionStatus> entities)
787            throws PersistenceDatabaseException {
788        if(entities.size() > 0) {
789            PreparedStatement _ps = session.prepareStatement(SQL_UPDATE);
790            int _modifiedEntities = 0;
791            
792            try {
793                for(PartyTrainingClassSessionStatus entity : entities) {
794                    if(bindForStore(_ps, entity.getPartyTrainingClassSessionStatusValue())) {
795                        _ps.addBatch();
796                        _modifiedEntities++;
797                    }
798                }
799                
800                if(_modifiedEntities != 0) {
801                    if(PersistenceDebugFlags.CheckEntityUpdateRowCount) {
802                        int[] _counts = _ps.executeBatch();
803                        
804                        for(int _countOffset = 0 ; _countOffset < _modifiedEntities  ; _countOffset++) {
805                            if(_counts[_countOffset] != 1 && _counts[_countOffset] != PreparedStatement.SUCCESS_NO_INFO) {
806                                throw new PersistenceDatabaseUpdateException("batch update failed, _counts[" + _countOffset + "] = " + _counts[_countOffset]);
807                            }
808                        }
809                    } else {
810                         _ps.executeBatch();
811                    }
812                    
813                    _ps.clearBatch();
814                    
815                    entities.forEach((entity) -> {
816                        session.getValueCache().put(entity.getPartyTrainingClassSessionStatusValue());
817                    });
818                }
819            } catch (SQLException se) {
820                throw new PersistenceDatabaseException(se);
821            }
822        }
823    }
824    
825    @Override
826    public void remove(PartyTrainingClassSessionStatus entity)
827            throws PersistenceDatabaseException {
828        remove(entity.getPrimaryKey());
829    }
830    
831    @Override
832    public void remove(PartyTrainingClassSessionStatusPK pk)
833            throws PersistenceDatabaseException {
834        PreparedStatement _ps = session.prepareStatement(SQL_DELETE);
835        long _entityId = pk.getEntityId();
836        
837        try {
838            _ps.setLong(1, _entityId);
839            
840            if(PersistenceDebugFlags.CheckEntityDeleteRowCount) {
841                int _count = _ps.executeUpdate();
842                
843                if(_count != 1) {
844                    throw new PersistenceDatabaseUpdateException("remove failed, _count = " + _count);
845                }
846            } else {
847                 _ps.executeUpdate();
848            }
849            
850            session.getValueCache().remove(pk);
851        } catch (SQLException se) {
852            throw new PersistenceDatabaseException(se);
853        }
854        
855        session.removed(pk, false);
856    }
857    
858    @Override
859    public void remove(Collection<PartyTrainingClassSessionStatusPK> pks)
860            throws PersistenceDatabaseException {
861        if(pks.size() > 0) {
862            PreparedStatement _ps = session.prepareStatement(SQL_DELETE);
863            int _modifiedEntities = 0;
864            
865            try {
866                for(PartyTrainingClassSessionStatusPK pk : pks) {
867                    long _entityId = pk.getEntityId();
868                    
869                    _ps.setLong(1, _entityId);
870                    
871                    _ps.addBatch();
872                    _modifiedEntities++;
873                }
874                
875                if(_modifiedEntities != 0) {
876                    if(PersistenceDebugFlags.CheckEntityDeleteRowCount) {
877                        int[] _counts = _ps.executeBatch();
878                        
879                        for(int _countOffset = 0 ; _countOffset < _modifiedEntities  ; _countOffset++) {
880                            if(_counts[_countOffset] != 1 && _counts[_countOffset] != PreparedStatement.SUCCESS_NO_INFO) {
881                                throw new PersistenceDatabaseUpdateException("batch remove failed, _counts[" + _countOffset + "] = " + _counts[_countOffset]);
882                            }
883                        }
884                    } else {
885                        _ps.executeBatch();
886                    }
887                    
888                    _ps.clearBatch();
889                    
890                    pks.forEach((pk) -> {
891                        session.getValueCache().remove(pk);
892                    });
893                }
894            } catch (SQLException se) {
895                throw new PersistenceDatabaseException(se);
896            }
897            
898            pks.forEach((pk) -> {
899                session.removed(pk, true);
900            });
901        }
902    }
903    
904    @Override
905    public boolean validPK(PartyTrainingClassSessionStatusPK pk)
906            throws PersistenceDatabaseException {
907        boolean valid = false;
908        PreparedStatement _ps = session.prepareStatement(SQL_VALID);
909        ResultSet _rs = null;
910        
911        try {
912            _ps.setLong(1, pk.getEntityId());
913            
914            _rs = _ps.executeQuery();
915            if(_rs.next()) {
916                long _count = _rs.getLong(1);
917                if(_rs.wasNull())
918                    _count = 0;
919                
920                if(_count == 1)
921                    valid = true;
922            }
923        } catch (SQLException se) {
924            throw new PersistenceDatabaseException(se);
925        } finally {
926            if(_rs != null) {
927                try {
928                    _rs.close();
929                } catch (SQLException se) {
930                    // do nothing
931                }
932            }
933        }
934        
935        return valid;
936    }
937    
938}