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