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