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 * PartyTrainingClassSessionSectionFactory.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.TrainingClassSectionPK;
027
028import com.echothree.model.data.training.server.entity.PartyTrainingClassSession;
029import com.echothree.model.data.training.server.entity.TrainingClassSection;
030
031import com.echothree.model.data.training.common.PartyTrainingClassSessionSectionConstants;
032import com.echothree.model.data.training.common.pk.PartyTrainingClassSessionSectionPK;
033import com.echothree.model.data.training.server.value.PartyTrainingClassSessionSectionValue;
034import com.echothree.model.data.training.server.entity.PartyTrainingClassSessionSection;
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 PartyTrainingClassSessionSectionFactory
064        implements BaseFactory<PartyTrainingClassSessionSectionPK, PartyTrainingClassSessionSection> {
065    
066    @Inject
067    Session session;
068    
069    //private static final Logger log = LoggerFactory.getLogger(PartyTrainingClassSessionSectionFactory.class);
070    
071    final private static String SQL_SELECT_READ_ONLY = "SELECT ptrnclss_partytrainingclasssessionsectionid, ptrnclss_ptrnclssess_partytrainingclasssessionid, ptrnclss_partytrainingclasssessionsectionsequence, ptrnclss_trnclss_trainingclasssectionid, ptrnclss_readingstarttime, ptrnclss_readingendtime, ptrnclss_fromtime, ptrnclss_thrutime FROM partytrainingclasssessionsections WHERE ptrnclss_partytrainingclasssessionsectionid = ?";
072    final private static String SQL_SELECT_READ_WRITE = "SELECT ptrnclss_partytrainingclasssessionsectionid, ptrnclss_ptrnclssess_partytrainingclasssessionid, ptrnclss_partytrainingclasssessionsectionsequence, ptrnclss_trnclss_trainingclasssectionid, ptrnclss_readingstarttime, ptrnclss_readingendtime, ptrnclss_fromtime, ptrnclss_thrutime FROM partytrainingclasssessionsections WHERE ptrnclss_partytrainingclasssessionsectionid = ? FOR UPDATE";
073    final private static String SQL_INSERT = "INSERT INTO partytrainingclasssessionsections (ptrnclss_partytrainingclasssessionsectionid, ptrnclss_ptrnclssess_partytrainingclasssessionid, ptrnclss_partytrainingclasssessionsectionsequence, ptrnclss_trnclss_trainingclasssectionid, ptrnclss_readingstarttime, ptrnclss_readingendtime, ptrnclss_fromtime, ptrnclss_thrutime) VALUES (?, ?, ?, ?, ?, ?, ?, ?)";
074    final private static String SQL_UPDATE = "UPDATE partytrainingclasssessionsections SET ptrnclss_ptrnclssess_partytrainingclasssessionid = ?, ptrnclss_partytrainingclasssessionsectionsequence = ?, ptrnclss_trnclss_trainingclasssectionid = ?, ptrnclss_readingstarttime = ?, ptrnclss_readingendtime = ?, ptrnclss_fromtime = ?, ptrnclss_thrutime = ? WHERE ptrnclss_partytrainingclasssessionsectionid = ?";
075    final private static String SQL_DELETE = "DELETE FROM partytrainingclasssessionsections WHERE ptrnclss_partytrainingclasssessionsectionid = ?";
076    final private static String SQL_VALID = "SELECT COUNT(*) FROM partytrainingclasssessionsections WHERE ptrnclss_partytrainingclasssessionsectionid = ?";
077    
078    final public static String PTRNCLSS_PARTYTRAININGCLASSSESSIONSECTIONID = "ptrnclss_partytrainingclasssessionsectionid";
079    final public static String PTRNCLSS_PTRNCLSSESS_PARTYTRAININGCLASSSESSIONID = "ptrnclss_ptrnclssess_partytrainingclasssessionid";
080    final public static String PTRNCLSS_PARTYTRAININGCLASSSESSIONSECTIONSEQUENCE = "ptrnclss_partytrainingclasssessionsectionsequence";
081    final public static String PTRNCLSS_TRNCLSS_TRAININGCLASSSECTIONID = "ptrnclss_trnclss_trainingclasssectionid";
082    final public static String PTRNCLSS_READINGSTARTTIME = "ptrnclss_readingstarttime";
083    final public static String PTRNCLSS_READINGENDTIME = "ptrnclss_readingendtime";
084    final public static String PTRNCLSS_FROMTIME = "ptrnclss_fromtime";
085    final public static String PTRNCLSS_THRUTIME = "ptrnclss_thrutime";
086    
087    final private static EntityIdGenerator entityIdGenerator = new EntityIdGenerator(PartyTrainingClassSessionSectionConstants.COMPONENT_VENDOR_NAME, PartyTrainingClassSessionSectionConstants.ENTITY_TYPE_NAME);
088    
089    /** Creates a new instance of PartyTrainingClassSessionSectionFactory */
090    protected PartyTrainingClassSessionSectionFactory() {
091        super();
092    }
093    
094    public static PartyTrainingClassSessionSectionFactory getInstance() {
095        return CDI.current().select(PartyTrainingClassSessionSectionFactory.class).get();
096    }
097    
098    @Override
099    public String getComponentVendorName() {
100        return PartyTrainingClassSessionSectionConstants.COMPONENT_VENDOR_NAME;
101    }
102    
103    @Override
104    public String getEntityTypeName() {
105        return PartyTrainingClassSessionSectionConstants.ENTITY_TYPE_NAME;
106    }
107    
108    public PreparedStatement prepareStatement(String query) {
109        return session.prepareStatement(query);
110    }
111    
112    public PartyTrainingClassSessionSectionPK getNextPK() {
113        return new PartyTrainingClassSessionSectionPK(entityIdGenerator.getNextEntityId());
114    }
115    
116    public Set<PartyTrainingClassSessionSectionPK> getPKsFromResultSetAsSet(ResultSet rs)
117            throws PersistenceDatabaseException {
118        Set<PartyTrainingClassSessionSectionPK> _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<PartyTrainingClassSessionSectionPK> getPKsFromResultSetAsList(ResultSet rs)
132            throws PersistenceDatabaseException {
133        java.util.List<PartyTrainingClassSessionSectionPK> _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 PartyTrainingClassSessionSectionPK getPKFromResultSet(ResultSet rs)
147            throws PersistenceDatabaseException {
148        PartyTrainingClassSessionSectionPK _result;
149        
150        try {
151            long ptrnclss_partytrainingclasssessionsectionid = rs.getLong(PTRNCLSS_PARTYTRAININGCLASSSESSIONSECTIONID);
152            Long _entityId = rs.wasNull() ? null : ptrnclss_partytrainingclasssessionsectionid;
153            
154            _result = new PartyTrainingClassSessionSectionPK(_entityId);
155        } catch (SQLException se) {
156            throw new PersistenceDatabaseException(se);
157        }
158        
159        return _result;
160    }
161    
162    public java.util.List<PartyTrainingClassSessionSectionValue> getValuesFromPKs(Collection<PartyTrainingClassSessionSectionPK> pks)
163            throws PersistenceDatabaseException {
164        java.util.List<PartyTrainingClassSessionSectionValue> _values = new ArrayList<>(pks.size());
165        
166        for(PartyTrainingClassSessionSectionPK _pk: pks) {
167            _values.add(getValueFromPK(_pk));
168        }
169        
170        return _values;
171    }
172    
173    public PartyTrainingClassSessionSectionValue getValueFromPK(PartyTrainingClassSessionSectionPK pk)
174            throws PersistenceDatabaseException {
175        PartyTrainingClassSessionSectionValue _value;
176        
177        // See if we already have the entity in the session cache
178        PartyTrainingClassSessionSection _entity = (PartyTrainingClassSessionSection)session.getEntity(pk);
179        if(_entity == null)
180            _value = getEntityFromPK(EntityPermission.READ_ONLY, pk).getPartyTrainingClassSessionSectionValue();
181        else
182            _value = _entity.getPartyTrainingClassSessionSectionValue();
183        
184        return _value;
185    }
186    
187    public java.util.List<PartyTrainingClassSessionSectionValue> getValuesFromResultSet(ResultSet rs)
188            throws PersistenceDatabaseException {
189        java.util.List<PartyTrainingClassSessionSectionValue> _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 PartyTrainingClassSessionSectionValue getValueFromResultSet(ResultSet rs)
203            throws PersistenceDatabaseException {
204        PartyTrainingClassSessionSectionValue _value;
205        
206        try {
207            Long ptrnclss_partytrainingclasssessionsectionid = rs.getLong(PTRNCLSS_PARTYTRAININGCLASSSESSIONSECTIONID);
208            PartyTrainingClassSessionSectionPK _pk = new PartyTrainingClassSessionSectionPK(ptrnclss_partytrainingclasssessionsectionid);
209            
210            // See if we already have the entity in the session cache
211            PartyTrainingClassSessionSection _entity = (PartyTrainingClassSessionSection)session.getEntity(_pk);
212            
213            if(_entity == null) {
214                Long ptrnclss_ptrnclssess_partytrainingclasssessionid = rs.getLong(PTRNCLSS_PTRNCLSSESS_PARTYTRAININGCLASSSESSIONID);
215                if(rs.wasNull())
216                    ptrnclss_ptrnclssess_partytrainingclasssessionid = null;
217                
218                Integer ptrnclss_partytrainingclasssessionsectionsequence = rs.getInt(PTRNCLSS_PARTYTRAININGCLASSSESSIONSECTIONSEQUENCE);
219                if(rs.wasNull())
220                    ptrnclss_partytrainingclasssessionsectionsequence = null;
221                
222                Long ptrnclss_trnclss_trainingclasssectionid = rs.getLong(PTRNCLSS_TRNCLSS_TRAININGCLASSSECTIONID);
223                if(rs.wasNull())
224                    ptrnclss_trnclss_trainingclasssectionid = null;
225                
226                Long ptrnclss_readingstarttime = rs.getLong(PTRNCLSS_READINGSTARTTIME);
227                if(rs.wasNull())
228                    ptrnclss_readingstarttime = null;
229                
230                Long ptrnclss_readingendtime = rs.getLong(PTRNCLSS_READINGENDTIME);
231                if(rs.wasNull())
232                    ptrnclss_readingendtime = null;
233                
234                Long ptrnclss_fromtime = rs.getLong(PTRNCLSS_FROMTIME);
235                if(rs.wasNull())
236                    ptrnclss_fromtime = null;
237                
238                Long ptrnclss_thrutime = rs.getLong(PTRNCLSS_THRUTIME);
239                if(rs.wasNull())
240                    ptrnclss_thrutime = null;
241                
242                _value = new PartyTrainingClassSessionSectionValue(_pk, new PartyTrainingClassSessionPK(ptrnclss_ptrnclssess_partytrainingclasssessionid), ptrnclss_partytrainingclasssessionsectionsequence, new TrainingClassSectionPK(ptrnclss_trnclss_trainingclasssectionid), ptrnclss_readingstarttime, ptrnclss_readingendtime, ptrnclss_fromtime, ptrnclss_thrutime);
243            } else
244                _value = _entity.getPartyTrainingClassSessionSectionValue();
245        } catch (SQLException se) {
246            throw new PersistenceDatabaseException(se);
247        }
248        
249        return _value;
250    }
251    
252    public java.util.List<PartyTrainingClassSessionSection> getEntitiesFromPKs(EntityPermission entityPermission, Collection<PartyTrainingClassSessionSectionPK> pks)
253            throws PersistenceDatabaseException {
254        java.util.List<PartyTrainingClassSessionSection> _entities = new ArrayList<>(pks.size());
255        
256        for(PartyTrainingClassSessionSectionPK _pk: pks) {
257            _entities.add(getEntityFromPK(entityPermission, _pk));
258        }
259        
260        return _entities;
261    }
262    
263    public PartyTrainingClassSessionSection getEntityFromValue(EntityPermission entityPermission, PartyTrainingClassSessionSectionValue value) {
264        return getEntityFromPK(entityPermission, value.getPrimaryKey());
265    }
266    
267    public PartyTrainingClassSessionSection getEntityFromCache(PartyTrainingClassSessionSectionPK pk) {
268        PartyTrainingClassSessionSectionValue _value = (PartyTrainingClassSessionSectionValue)session.getValueCache().get(pk);
269    
270        return _value == null ? null : new PartyTrainingClassSessionSection(_value, EntityPermission.READ_ONLY);
271    }
272    
273    public PartyTrainingClassSessionSection getEntityFromPK(EntityPermission entityPermission, PartyTrainingClassSessionSectionPK pk)
274            throws PersistenceDatabaseException {
275        PartyTrainingClassSessionSection _entity;
276        
277        // See if we already have the entity in the session cache
278        _entity = (PartyTrainingClassSessionSection)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<PartyTrainingClassSessionSectionPK> getPKsFromQueryAsSet(PreparedStatement ps, final Object... params)
321            throws PersistenceDatabaseException {
322        Set<PartyTrainingClassSessionSectionPK> _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<PartyTrainingClassSessionSectionPK> getPKsFromQueryAsList(PreparedStatement ps, final Object... params)
349            throws PersistenceDatabaseException {
350        java.util.List<PartyTrainingClassSessionSectionPK> _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 PartyTrainingClassSessionSectionPK getPKFromQuery(PreparedStatement ps, final Object... params)
377            throws PersistenceDatabaseException {
378        PartyTrainingClassSessionSectionPK _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<PartyTrainingClassSessionSection> 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<PartyTrainingClassSessionSection> 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<PartyTrainingClassSessionSection> 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<PartyTrainingClassSessionSection> getEntitiesFromQuery(EntityPermission entityPermission, PreparedStatement ps, final Object... params)
428            throws PersistenceDatabaseException {
429        java.util.List<PartyTrainingClassSessionSection> _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 PartyTrainingClassSessionSection 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 PartyTrainingClassSessionSection 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 PartyTrainingClassSessionSection 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 PartyTrainingClassSessionSection getEntityFromQuery(EntityPermission entityPermission, PreparedStatement ps, final Object... params)
477            throws PersistenceDatabaseException {
478        PartyTrainingClassSessionSection _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<PartyTrainingClassSessionSection> getEntitiesFromResultSet(EntityPermission entityPermission, ResultSet rs)
507            throws PersistenceDatabaseException {
508        java.util.List<PartyTrainingClassSessionSection> _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 PartyTrainingClassSessionSection getEntityFromResultSet(EntityPermission entityPermission, ResultSet rs)
522            throws PersistenceDatabaseException {
523        PartyTrainingClassSessionSection _entity;
524        
525        try {
526            Long ptrnclss_partytrainingclasssessionsectionid = rs.getLong(PTRNCLSS_PARTYTRAININGCLASSSESSIONSECTIONID);
527            PartyTrainingClassSessionSectionPK _pk = new PartyTrainingClassSessionSectionPK(ptrnclss_partytrainingclasssessionsectionid);
528            
529            // See if we already have the entity in the session cache
530            _entity = (PartyTrainingClassSessionSection)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 ptrnclss_ptrnclssess_partytrainingclasssessionid = rs.getLong(PTRNCLSS_PTRNCLSSESS_PARTYTRAININGCLASSSESSIONID);
548                if(rs.wasNull())
549                    ptrnclss_ptrnclssess_partytrainingclasssessionid = null;
550                
551                Integer ptrnclss_partytrainingclasssessionsectionsequence = rs.getInt(PTRNCLSS_PARTYTRAININGCLASSSESSIONSECTIONSEQUENCE);
552                if(rs.wasNull())
553                    ptrnclss_partytrainingclasssessionsectionsequence = null;
554                
555                Long ptrnclss_trnclss_trainingclasssectionid = rs.getLong(PTRNCLSS_TRNCLSS_TRAININGCLASSSECTIONID);
556                if(rs.wasNull())
557                    ptrnclss_trnclss_trainingclasssectionid = null;
558                
559                Long ptrnclss_readingstarttime = rs.getLong(PTRNCLSS_READINGSTARTTIME);
560                if(rs.wasNull())
561                    ptrnclss_readingstarttime = null;
562                
563                Long ptrnclss_readingendtime = rs.getLong(PTRNCLSS_READINGENDTIME);
564                if(rs.wasNull())
565                    ptrnclss_readingendtime = null;
566                
567                Long ptrnclss_fromtime = rs.getLong(PTRNCLSS_FROMTIME);
568                if(rs.wasNull())
569                    ptrnclss_fromtime = null;
570                
571                Long ptrnclss_thrutime = rs.getLong(PTRNCLSS_THRUTIME);
572                if(rs.wasNull())
573                    ptrnclss_thrutime = null;
574                
575                PartyTrainingClassSessionSectionValue _value = new PartyTrainingClassSessionSectionValue(_pk, ptrnclss_ptrnclssess_partytrainingclasssessionid == null? null: new PartyTrainingClassSessionPK(ptrnclss_ptrnclssess_partytrainingclasssessionid), ptrnclss_partytrainingclasssessionsectionsequence, ptrnclss_trnclss_trainingclasssectionid == null? null: new TrainingClassSectionPK(ptrnclss_trnclss_trainingclasssectionid), ptrnclss_readingstarttime, ptrnclss_readingendtime, ptrnclss_fromtime, ptrnclss_thrutime);
576                _entity = new PartyTrainingClassSessionSection(_value, entityPermission);
577            }
578            
579            if(!foundInSessionCache) {
580                if(entityPermission.equals(EntityPermission.READ_ONLY)) {
581                    session.putReadOnlyEntity(_pk, _entity);
582                    session.getValueCache().put(_entity.getPartyTrainingClassSessionSectionValue());
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 PartyTrainingClassSessionSection create(PartyTrainingClassSession partyTrainingClassSession, Integer partyTrainingClassSessionSectionSequence, TrainingClassSection trainingClassSection, Long readingStartTime, Long readingEndTime, Long fromTime, Long thruTime)
595            throws PersistenceDatabaseException, PersistenceNotNullException {
596        return create(partyTrainingClassSession == null ? null : partyTrainingClassSession.getPrimaryKey(), partyTrainingClassSessionSectionSequence, trainingClassSection == null ? null : trainingClassSection.getPrimaryKey(), readingStartTime, readingEndTime, fromTime, thruTime);
597    }
598    
599    private void bindForCreate(PreparedStatement _ps, PartyTrainingClassSessionSectionValue _value)
600            throws SQLException {
601        _ps.setLong(1, _value.getEntityId());
602        
603        PartyTrainingClassSessionPK ptrnclss_ptrnclssess_partytrainingclasssessionid = _value.getPartyTrainingClassSessionPK();
604        if(ptrnclss_ptrnclssess_partytrainingclasssessionid == null)
605            _ps.setNull(2, Types.BIGINT);
606        else
607            _ps.setLong(2, ptrnclss_ptrnclssess_partytrainingclasssessionid.getEntityId());
608            
609        Integer ptrnclss_partytrainingclasssessionsectionsequence = _value.getPartyTrainingClassSessionSectionSequence();
610        if(ptrnclss_partytrainingclasssessionsectionsequence == null)
611            _ps.setNull(3, Types.INTEGER);
612        else
613            _ps.setInt(3, ptrnclss_partytrainingclasssessionsectionsequence);
614            
615        TrainingClassSectionPK ptrnclss_trnclss_trainingclasssectionid = _value.getTrainingClassSectionPK();
616        if(ptrnclss_trnclss_trainingclasssectionid == null)
617            _ps.setNull(4, Types.BIGINT);
618        else
619            _ps.setLong(4, ptrnclss_trnclss_trainingclasssectionid.getEntityId());
620            
621        Long ptrnclss_readingstarttime = _value.getReadingStartTime();
622        if(ptrnclss_readingstarttime == null)
623            _ps.setNull(5, Types.BIGINT);
624        else
625            _ps.setLong(5, ptrnclss_readingstarttime);
626            
627        Long ptrnclss_readingendtime = _value.getReadingEndTime();
628        if(ptrnclss_readingendtime == null)
629            _ps.setNull(6, Types.BIGINT);
630        else
631            _ps.setLong(6, ptrnclss_readingendtime);
632            
633        Long ptrnclss_fromtime = _value.getFromTime();
634        if(ptrnclss_fromtime == null)
635            _ps.setNull(7, Types.BIGINT);
636        else
637            _ps.setLong(7, ptrnclss_fromtime);
638            
639        Long ptrnclss_thrutime = _value.getThruTime();
640        if(ptrnclss_thrutime == null)
641            _ps.setNull(8, Types.BIGINT);
642        else
643            _ps.setLong(8, ptrnclss_thrutime);
644            
645    }
646    
647    public PartyTrainingClassSessionSection create(PartyTrainingClassSessionPK partyTrainingClassSessionPK, Integer partyTrainingClassSessionSectionSequence, TrainingClassSectionPK trainingClassSectionPK, Long readingStartTime, Long readingEndTime, Long fromTime, Long thruTime)
648            throws PersistenceDatabaseException, PersistenceNotNullException {
649        PartyTrainingClassSessionSectionPK _pk = getNextPK();
650        PartyTrainingClassSessionSectionValue _value = new PartyTrainingClassSessionSectionValue(_pk, partyTrainingClassSessionPK, partyTrainingClassSessionSectionSequence, trainingClassSectionPK, readingStartTime, readingEndTime, 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        PartyTrainingClassSessionSection _entity = new PartyTrainingClassSessionSection(_value, EntityPermission.READ_ONLY);
673        session.putReadOnlyEntity(_pk, _entity);
674        
675        return _entity;
676    }
677    
678    public void create(Collection<PartyTrainingClassSessionSectionValue> _values)
679            throws PersistenceDatabaseException, PersistenceNotNullException {
680        int _size = _values.size();
681        
682        if(_size > 0) {
683            PreparedStatement _ps = session.prepareStatement(SQL_INSERT);
684            List<PartyTrainingClassSessionSectionValue> _cacheValues = new ArrayList<>(_size);
685            
686            try {
687                for(PartyTrainingClassSessionSectionValue _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                PartyTrainingClassSessionSection _cacheEntity = new PartyTrainingClassSessionSection(_cacheValue, EntityPermission.READ_ONLY);
715                
716                session.putReadOnlyEntity(_cacheValue.getPrimaryKey(), _cacheEntity);
717            });
718        }
719    }
720    
721    private boolean bindForStore(PreparedStatement _ps, PartyTrainingClassSessionSectionValue _value)
722            throws SQLException {
723        boolean _hasBeenModified = _value.hasBeenModified();
724        
725        if(_hasBeenModified) {
726            PartyTrainingClassSessionPK ptrnclss_ptrnclssess_partytrainingclasssessionid = _value.getPartyTrainingClassSessionPK();
727            if(ptrnclss_ptrnclssess_partytrainingclasssessionid == null)
728                _ps.setNull(1, Types.BIGINT);
729            else
730                _ps.setLong(1, ptrnclss_ptrnclssess_partytrainingclasssessionid.getEntityId());
731            
732            Integer ptrnclss_partytrainingclasssessionsectionsequence = _value.getPartyTrainingClassSessionSectionSequence();
733            if(ptrnclss_partytrainingclasssessionsectionsequence == null)
734                _ps.setNull(2, Types.INTEGER);
735            else
736                _ps.setInt(2, ptrnclss_partytrainingclasssessionsectionsequence);
737            
738            TrainingClassSectionPK ptrnclss_trnclss_trainingclasssectionid = _value.getTrainingClassSectionPK();
739            if(ptrnclss_trnclss_trainingclasssectionid == null)
740                _ps.setNull(3, Types.BIGINT);
741            else
742                _ps.setLong(3, ptrnclss_trnclss_trainingclasssectionid.getEntityId());
743            
744            Long ptrnclss_readingstarttime = _value.getReadingStartTime();
745            if(ptrnclss_readingstarttime == null)
746                _ps.setNull(4, Types.BIGINT);
747            else
748                _ps.setLong(4, ptrnclss_readingstarttime);
749            
750            Long ptrnclss_readingendtime = _value.getReadingEndTime();
751            if(ptrnclss_readingendtime == null)
752                _ps.setNull(5, Types.BIGINT);
753            else
754                _ps.setLong(5, ptrnclss_readingendtime);
755            
756            Long ptrnclss_fromtime = _value.getFromTime();
757            if(ptrnclss_fromtime == null)
758                _ps.setNull(6, Types.BIGINT);
759            else
760                _ps.setLong(6, ptrnclss_fromtime);
761            
762            Long ptrnclss_thrutime = _value.getThruTime();
763            if(ptrnclss_thrutime == null)
764                _ps.setNull(7, Types.BIGINT);
765            else
766                _ps.setLong(7, ptrnclss_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(PartyTrainingClassSessionSection entity)
778            throws PersistenceDatabaseException {
779        PreparedStatement _ps = session.prepareStatement(SQL_UPDATE);
780        
781        try {
782            PartyTrainingClassSessionSectionValue _value = entity.getPartyTrainingClassSessionSectionValue();
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<PartyTrainingClassSessionSection> 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(PartyTrainingClassSessionSection entity : entities) {
811                    if(bindForStore(_ps, entity.getPartyTrainingClassSessionSectionValue())) {
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.getPartyTrainingClassSessionSectionValue());
834                    });
835                }
836            } catch (SQLException se) {
837                throw new PersistenceDatabaseException(se);
838            }
839        }
840    }
841    
842    @Override
843    public void remove(PartyTrainingClassSessionSection entity)
844            throws PersistenceDatabaseException {
845        remove(entity.getPrimaryKey());
846    }
847    
848    @Override
849    public void remove(PartyTrainingClassSessionSectionPK 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<PartyTrainingClassSessionSectionPK> 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(PartyTrainingClassSessionSectionPK 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(PartyTrainingClassSessionSectionPK 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}