Source code

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