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 * FinancialAccountTransactionDetailFactory.java
021 */
022
023package com.echothree.model.data.financial.server.factory;
024
025import com.echothree.model.data.financial.common.pk.FinancialAccountTransactionPK;
026import com.echothree.model.data.financial.common.pk.FinancialAccountPK;
027import com.echothree.model.data.financial.common.pk.FinancialAccountTransactionTypePK;
028
029import com.echothree.model.data.financial.server.entity.FinancialAccountTransaction;
030import com.echothree.model.data.financial.server.entity.FinancialAccount;
031import com.echothree.model.data.financial.server.entity.FinancialAccountTransactionType;
032
033import com.echothree.model.data.financial.common.FinancialAccountTransactionDetailConstants;
034import com.echothree.model.data.financial.common.pk.FinancialAccountTransactionDetailPK;
035import com.echothree.model.data.financial.server.value.FinancialAccountTransactionDetailValue;
036import com.echothree.model.data.financial.server.entity.FinancialAccountTransactionDetail;
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 FinancialAccountTransactionDetailFactory
062        implements BaseFactory<FinancialAccountTransactionDetailPK, FinancialAccountTransactionDetail> {
063    
064    //final private static Log log = LogFactory.getLog(FinancialAccountTransactionDetailFactory.class);
065    
066    final private static String SQL_SELECT_READ_ONLY = "SELECT finatrxdt_financialaccounttransactiondetailid, finatrxdt_finatrx_financialaccounttransactionid, finatrxdt_financialaccounttransactionname, finatrxdt_fina_financialaccountid, finatrxdt_fnatrxtyp_financialaccounttransactiontypeid, finatrxdt_amount, finatrxdt_comment, finatrxdt_fromtime, finatrxdt_thrutime FROM financialaccounttransactiondetails WHERE finatrxdt_financialaccounttransactiondetailid = ?";
067    final private static String SQL_SELECT_READ_WRITE = "SELECT finatrxdt_financialaccounttransactiondetailid, finatrxdt_finatrx_financialaccounttransactionid, finatrxdt_financialaccounttransactionname, finatrxdt_fina_financialaccountid, finatrxdt_fnatrxtyp_financialaccounttransactiontypeid, finatrxdt_amount, finatrxdt_comment, finatrxdt_fromtime, finatrxdt_thrutime FROM financialaccounttransactiondetails WHERE finatrxdt_financialaccounttransactiondetailid = ? FOR UPDATE";
068    final private static String SQL_INSERT = "INSERT INTO financialaccounttransactiondetails (finatrxdt_financialaccounttransactiondetailid, finatrxdt_finatrx_financialaccounttransactionid, finatrxdt_financialaccounttransactionname, finatrxdt_fina_financialaccountid, finatrxdt_fnatrxtyp_financialaccounttransactiontypeid, finatrxdt_amount, finatrxdt_comment, finatrxdt_fromtime, finatrxdt_thrutime) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)";
069    final private static String SQL_UPDATE = "UPDATE financialaccounttransactiondetails SET finatrxdt_finatrx_financialaccounttransactionid = ?, finatrxdt_financialaccounttransactionname = ?, finatrxdt_fina_financialaccountid = ?, finatrxdt_fnatrxtyp_financialaccounttransactiontypeid = ?, finatrxdt_amount = ?, finatrxdt_comment = ?, finatrxdt_fromtime = ?, finatrxdt_thrutime = ? WHERE finatrxdt_financialaccounttransactiondetailid = ?";
070    final private static String SQL_DELETE = "DELETE FROM financialaccounttransactiondetails WHERE finatrxdt_financialaccounttransactiondetailid = ?";
071    final private static String SQL_VALID = "SELECT COUNT(*) FROM financialaccounttransactiondetails WHERE finatrxdt_financialaccounttransactiondetailid = ?";
072    
073    final private static String PK_COLUMN = "finatrxdt_financialaccounttransactiondetailid";
074    final private static String ALL_COLUMNS = "finatrxdt_financialaccounttransactiondetailid, finatrxdt_finatrx_financialaccounttransactionid, finatrxdt_financialaccounttransactionname, finatrxdt_fina_financialaccountid, finatrxdt_fnatrxtyp_financialaccounttransactiontypeid, finatrxdt_amount, finatrxdt_comment, finatrxdt_fromtime, finatrxdt_thrutime";
075    final public static String TABLE_NAME = "financialaccounttransactiondetails";
076    
077    final public static String FINATRXDT_FINANCIALACCOUNTTRANSACTIONDETAILID = "finatrxdt_financialaccounttransactiondetailid";
078    final public static String FINATRXDT_FINATRX_FINANCIALACCOUNTTRANSACTIONID = "finatrxdt_finatrx_financialaccounttransactionid";
079    final public static String FINATRXDT_FINANCIALACCOUNTTRANSACTIONNAME = "finatrxdt_financialaccounttransactionname";
080    final public static String FINATRXDT_FINA_FINANCIALACCOUNTID = "finatrxdt_fina_financialaccountid";
081    final public static String FINATRXDT_FNATRXTYP_FINANCIALACCOUNTTRANSACTIONTYPEID = "finatrxdt_fnatrxtyp_financialaccounttransactiontypeid";
082    final public static String FINATRXDT_AMOUNT = "finatrxdt_amount";
083    final public static String FINATRXDT_COMMENT = "finatrxdt_comment";
084    final public static String FINATRXDT_FROMTIME = "finatrxdt_fromtime";
085    final public static String FINATRXDT_THRUTIME = "finatrxdt_thrutime";
086    
087    final private static EntityIdGenerator entityIdGenerator = new EntityIdGenerator(FinancialAccountTransactionDetailConstants.COMPONENT_VENDOR_NAME, FinancialAccountTransactionDetailConstants.ENTITY_TYPE_NAME);
088    
089    /** Creates a new instance of FinancialAccountTransactionDetailFactory */
090    private FinancialAccountTransactionDetailFactory() {
091        super();
092    }
093    
094    private static class FinancialAccountTransactionDetailFactoryHolder {
095        static FinancialAccountTransactionDetailFactory instance = new FinancialAccountTransactionDetailFactory();
096    }
097    
098    public static FinancialAccountTransactionDetailFactory getInstance() {
099        return FinancialAccountTransactionDetailFactoryHolder.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 FinancialAccountTransactionDetailConstants.COMPONENT_VENDOR_NAME;
120    }
121    
122    @Override
123    public String getEntityTypeName() {
124        return FinancialAccountTransactionDetailConstants.ENTITY_TYPE_NAME;
125    }
126    
127    public PreparedStatement prepareStatement(String query) {
128        return ThreadSession.currentSession().prepareStatement(FinancialAccountTransactionDetailFactory.class, query);
129    }
130    
131    public FinancialAccountTransactionDetailPK getNextPK() {
132        return new FinancialAccountTransactionDetailPK(entityIdGenerator.getNextEntityId());
133    }
134    
135    public Set<FinancialAccountTransactionDetailPK> getPKsFromResultSetAsSet(ResultSet rs)
136            throws PersistenceDatabaseException {
137        Set<FinancialAccountTransactionDetailPK> _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<FinancialAccountTransactionDetailPK> getPKsFromResultSetAsList(ResultSet rs)
151            throws PersistenceDatabaseException {
152        java.util.List<FinancialAccountTransactionDetailPK> _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 FinancialAccountTransactionDetailPK getPKFromResultSet(ResultSet rs)
166            throws PersistenceDatabaseException {
167        FinancialAccountTransactionDetailPK _result;
168        
169        try {
170            long finatrxdt_financialaccounttransactiondetailid = rs.getLong(FINATRXDT_FINANCIALACCOUNTTRANSACTIONDETAILID);
171            Long _entityId = rs.wasNull() ? null : finatrxdt_financialaccounttransactiondetailid;
172            
173            _result = new FinancialAccountTransactionDetailPK(_entityId);
174        } catch (SQLException se) {
175            throw new PersistenceDatabaseException(se);
176        }
177        
178        return _result;
179    }
180    
181    public java.util.List<FinancialAccountTransactionDetailValue> getValuesFromPKs(Session session, Collection<FinancialAccountTransactionDetailPK> pks)
182            throws PersistenceDatabaseException {
183        java.util.List<FinancialAccountTransactionDetailValue> _values = new ArrayList<>(pks.size());
184        
185        for(FinancialAccountTransactionDetailPK _pk: pks) {
186            _values.add(getValueFromPK(session, _pk));
187        }
188        
189        return _values;
190    }
191    
192    public FinancialAccountTransactionDetailValue getValueFromPK(Session session, FinancialAccountTransactionDetailPK pk)
193            throws PersistenceDatabaseException {
194        FinancialAccountTransactionDetailValue _value;
195        
196        // See if we already have the entity in the session cache
197        FinancialAccountTransactionDetail _entity = (FinancialAccountTransactionDetail)session.getEntity(pk);
198        if(_entity == null)
199            _value = getEntityFromPK(session, EntityPermission.READ_ONLY, pk).getFinancialAccountTransactionDetailValue();
200        else
201            _value = _entity.getFinancialAccountTransactionDetailValue();
202        
203        return _value;
204    }
205    
206    public java.util.List<FinancialAccountTransactionDetailValue> getValuesFromResultSet(Session session, ResultSet rs)
207            throws PersistenceDatabaseException {
208        java.util.List<FinancialAccountTransactionDetailValue> _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 FinancialAccountTransactionDetailValue getValueFromResultSet(Session session, ResultSet rs)
222            throws PersistenceDatabaseException {
223        FinancialAccountTransactionDetailValue _value;
224        
225        try {
226            Long finatrxdt_financialaccounttransactiondetailid = rs.getLong(FINATRXDT_FINANCIALACCOUNTTRANSACTIONDETAILID);
227            FinancialAccountTransactionDetailPK _pk = new FinancialAccountTransactionDetailPK(finatrxdt_financialaccounttransactiondetailid);
228            
229            // See if we already have the entity in the session cache
230            FinancialAccountTransactionDetail _entity = (FinancialAccountTransactionDetail)session.getEntity(_pk);
231            
232            if(_entity == null) {
233                Long finatrxdt_finatrx_financialaccounttransactionid = rs.getLong(FINATRXDT_FINATRX_FINANCIALACCOUNTTRANSACTIONID);
234                if(rs.wasNull())
235                    finatrxdt_finatrx_financialaccounttransactionid = null;
236                
237                String finatrxdt_financialaccounttransactionname = rs.getString(FINATRXDT_FINANCIALACCOUNTTRANSACTIONNAME);
238                if(rs.wasNull())
239                    finatrxdt_financialaccounttransactionname = null;
240                
241                Long finatrxdt_fina_financialaccountid = rs.getLong(FINATRXDT_FINA_FINANCIALACCOUNTID);
242                if(rs.wasNull())
243                    finatrxdt_fina_financialaccountid = null;
244                
245                Long finatrxdt_fnatrxtyp_financialaccounttransactiontypeid = rs.getLong(FINATRXDT_FNATRXTYP_FINANCIALACCOUNTTRANSACTIONTYPEID);
246                if(rs.wasNull())
247                    finatrxdt_fnatrxtyp_financialaccounttransactiontypeid = null;
248                
249                Long finatrxdt_amount = rs.getLong(FINATRXDT_AMOUNT);
250                if(rs.wasNull())
251                    finatrxdt_amount = null;
252                
253                String finatrxdt_comment = rs.getString(FINATRXDT_COMMENT);
254                if(rs.wasNull())
255                    finatrxdt_comment = null;
256                
257                Long finatrxdt_fromtime = rs.getLong(FINATRXDT_FROMTIME);
258                if(rs.wasNull())
259                    finatrxdt_fromtime = null;
260                
261                Long finatrxdt_thrutime = rs.getLong(FINATRXDT_THRUTIME);
262                if(rs.wasNull())
263                    finatrxdt_thrutime = null;
264                
265                _value = new FinancialAccountTransactionDetailValue(_pk, new FinancialAccountTransactionPK(finatrxdt_finatrx_financialaccounttransactionid), finatrxdt_financialaccounttransactionname, new FinancialAccountPK(finatrxdt_fina_financialaccountid), new FinancialAccountTransactionTypePK(finatrxdt_fnatrxtyp_financialaccounttransactiontypeid), finatrxdt_amount, finatrxdt_comment, finatrxdt_fromtime, finatrxdt_thrutime);
266            } else
267                _value = _entity.getFinancialAccountTransactionDetailValue();
268        } catch (SQLException se) {
269            throw new PersistenceDatabaseException(se);
270        }
271        
272        return _value;
273    }
274    
275    public java.util.List<FinancialAccountTransactionDetail> getEntitiesFromPKs(EntityPermission entityPermission, Collection<FinancialAccountTransactionDetailPK> pks)
276            throws PersistenceDatabaseException {
277        return getEntitiesFromPKs(ThreadSession.currentSession(), entityPermission, pks);
278    }
279    
280    public java.util.List<FinancialAccountTransactionDetail> getEntitiesFromPKs(Session session, EntityPermission entityPermission, Collection<FinancialAccountTransactionDetailPK> pks)
281            throws PersistenceDatabaseException {
282        java.util.List<FinancialAccountTransactionDetail> _entities = new ArrayList<>(pks.size());
283        
284        for(FinancialAccountTransactionDetailPK _pk: pks) {
285            _entities.add(getEntityFromPK(session, entityPermission, _pk));
286        }
287        
288        return _entities;
289    }
290    
291    public FinancialAccountTransactionDetail getEntityFromValue(EntityPermission entityPermission, FinancialAccountTransactionDetailValue value) {
292        return getEntityFromPK(ThreadSession.currentSession(), entityPermission, value.getPrimaryKey());
293    }
294    
295    public FinancialAccountTransactionDetail getEntityFromValue(Session session, EntityPermission entityPermission, FinancialAccountTransactionDetailValue value) {
296        return getEntityFromPK(session, entityPermission, value.getPrimaryKey());
297    }
298    
299    public FinancialAccountTransactionDetail getEntityFromPK(EntityPermission entityPermission, FinancialAccountTransactionDetailPK pk)
300            throws PersistenceDatabaseException {
301        return getEntityFromPK(ThreadSession.currentSession(), entityPermission, pk);
302    }
303    
304    public FinancialAccountTransactionDetail getEntityFromCache(Session session, FinancialAccountTransactionDetailPK pk) {
305        FinancialAccountTransactionDetailValue _value = (FinancialAccountTransactionDetailValue)session.getValueCache().get(pk);
306    
307        return _value == null ? null : new FinancialAccountTransactionDetail(_value, EntityPermission.READ_ONLY);
308    }
309    
310    public FinancialAccountTransactionDetail getEntityFromPK(Session session, EntityPermission entityPermission, FinancialAccountTransactionDetailPK pk)
311            throws PersistenceDatabaseException {
312        FinancialAccountTransactionDetail _entity;
313        
314        // See if we already have the entity in the session cache
315        _entity = (FinancialAccountTransactionDetail)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<FinancialAccountTransactionDetailPK> getPKsFromQueryAsSet(PreparedStatement ps, final Object... params)
358            throws PersistenceDatabaseException {
359        Set<FinancialAccountTransactionDetailPK> _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<FinancialAccountTransactionDetailPK> getPKsFromQueryAsList(PreparedStatement ps, final Object... params)
386            throws PersistenceDatabaseException {
387        java.util.List<FinancialAccountTransactionDetailPK> _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 FinancialAccountTransactionDetailPK getPKFromQuery(PreparedStatement ps, final Object... params)
414            throws PersistenceDatabaseException {
415        FinancialAccountTransactionDetailPK _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<FinancialAccountTransactionDetail> getEntitiesFromQuery(Session session, EntityPermission entityPermission, Map<EntityPermission, String>queryMap, final Object... params)
444            throws PersistenceDatabaseException {
445        PreparedStatement ps = session.prepareStatement(FinancialAccountTransactionDetailFactory.class, queryMap.get(entityPermission));
446        
447        return getEntitiesFromQuery(session, entityPermission, ps, params);
448    }
449    
450    public java.util.List<FinancialAccountTransactionDetail> getEntitiesFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap, final Object... params)
451            throws PersistenceDatabaseException {
452        Session session = ThreadSession.currentSession();
453        PreparedStatement ps = session.prepareStatement(FinancialAccountTransactionDetailFactory.class, queryMap.get(entityPermission));
454        
455        return getEntitiesFromQuery(session, entityPermission, ps, params);
456    }
457    
458    public java.util.List<FinancialAccountTransactionDetail> getEntitiesFromQuery(Session session, EntityPermission entityPermission, Map<EntityPermission, String>queryMap)
459            throws PersistenceDatabaseException {
460        PreparedStatement ps = session.prepareStatement(FinancialAccountTransactionDetailFactory.class, queryMap.get(entityPermission));
461        
462        return getEntitiesFromQuery(session, entityPermission, ps);
463    }
464    
465    public java.util.List<FinancialAccountTransactionDetail> getEntitiesFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap)
466            throws PersistenceDatabaseException {
467        Session session = ThreadSession.currentSession();
468        PreparedStatement ps = session.prepareStatement(FinancialAccountTransactionDetailFactory.class, queryMap.get(entityPermission));
469        
470        return getEntitiesFromQuery(session, entityPermission, ps);
471    }
472    
473    public java.util.List<FinancialAccountTransactionDetail> getEntitiesFromQuery(EntityPermission entityPermission, PreparedStatement ps)
474            throws PersistenceDatabaseException {
475        return getEntitiesFromQuery(ThreadSession.currentSession(), entityPermission, ps);
476    }
477    
478    public java.util.List<FinancialAccountTransactionDetail> 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<FinancialAccountTransactionDetail> getEntitiesFromQuery(Session session, EntityPermission entityPermission, PreparedStatement ps, final Object... params)
484            throws PersistenceDatabaseException {
485        java.util.List<FinancialAccountTransactionDetail> _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 FinancialAccountTransactionDetail getEntityFromQuery(Session session, EntityPermission entityPermission, Map<EntityPermission, String>queryMap, final Object... params)
512            throws PersistenceDatabaseException {
513        PreparedStatement ps = session.prepareStatement(FinancialAccountTransactionDetailFactory.class, queryMap.get(entityPermission));
514        
515        return getEntityFromQuery(session, entityPermission, ps, params);
516    }
517    
518    public FinancialAccountTransactionDetail getEntityFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap, final Object... params)
519            throws PersistenceDatabaseException {
520        Session session = ThreadSession.currentSession();
521        PreparedStatement ps = session.prepareStatement(FinancialAccountTransactionDetailFactory.class, queryMap.get(entityPermission));
522        
523        return getEntityFromQuery(session, entityPermission, ps, params);
524    }
525    
526    public FinancialAccountTransactionDetail getEntityFromQuery(Session session, EntityPermission entityPermission, Map<EntityPermission, String>queryMap)
527            throws PersistenceDatabaseException {
528        PreparedStatement ps = session.prepareStatement(FinancialAccountTransactionDetailFactory.class, queryMap.get(entityPermission));
529        
530        return getEntityFromQuery(session, entityPermission, ps);
531    }
532    
533    public FinancialAccountTransactionDetail getEntityFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap)
534            throws PersistenceDatabaseException {
535        Session session = ThreadSession.currentSession();
536        PreparedStatement ps = session.prepareStatement(FinancialAccountTransactionDetailFactory.class, queryMap.get(entityPermission));
537        
538        return getEntityFromQuery(session, entityPermission, ps);
539    }
540    
541    public FinancialAccountTransactionDetail getEntityFromQuery(EntityPermission entityPermission, PreparedStatement ps)
542            throws PersistenceDatabaseException {
543        return getEntityFromQuery(ThreadSession.currentSession(), entityPermission, ps);
544    }
545    
546    public FinancialAccountTransactionDetail getEntityFromQuery(EntityPermission entityPermission, PreparedStatement ps, final Object... params)
547            throws PersistenceDatabaseException {
548        return getEntityFromQuery(ThreadSession.currentSession(), entityPermission, ps, params);
549    }
550    
551    public FinancialAccountTransactionDetail getEntityFromQuery(Session session, EntityPermission entityPermission, PreparedStatement ps, final Object... params)
552            throws PersistenceDatabaseException {
553        FinancialAccountTransactionDetail _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<FinancialAccountTransactionDetail> getEntitiesFromResultSet(EntityPermission entityPermission, ResultSet rs)
582            throws PersistenceDatabaseException {
583        return getEntitiesFromResultSet(ThreadSession.currentSession(), entityPermission, rs);
584    }
585    
586    public java.util.List<FinancialAccountTransactionDetail> getEntitiesFromResultSet(Session session, EntityPermission entityPermission, ResultSet rs)
587            throws PersistenceDatabaseException {
588        java.util.List<FinancialAccountTransactionDetail> _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 FinancialAccountTransactionDetail getEntityFromResultSet(EntityPermission entityPermission, ResultSet rs)
602            throws PersistenceDatabaseException {
603        return getEntityFromResultSet(ThreadSession.currentSession(), entityPermission, rs);
604    }
605    
606    public FinancialAccountTransactionDetail getEntityFromResultSet(Session session, EntityPermission entityPermission, ResultSet rs)
607            throws PersistenceDatabaseException {
608        FinancialAccountTransactionDetail _entity;
609        
610        try {
611            Long finatrxdt_financialaccounttransactiondetailid = rs.getLong(FINATRXDT_FINANCIALACCOUNTTRANSACTIONDETAILID);
612            FinancialAccountTransactionDetailPK _pk = new FinancialAccountTransactionDetailPK(finatrxdt_financialaccounttransactiondetailid);
613            
614            // See if we already have the entity in the session cache
615            _entity = (FinancialAccountTransactionDetail)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 finatrxdt_finatrx_financialaccounttransactionid = rs.getLong(FINATRXDT_FINATRX_FINANCIALACCOUNTTRANSACTIONID);
633                if(rs.wasNull())
634                    finatrxdt_finatrx_financialaccounttransactionid = null;
635                
636                String finatrxdt_financialaccounttransactionname = rs.getString(FINATRXDT_FINANCIALACCOUNTTRANSACTIONNAME);
637                if(rs.wasNull())
638                    finatrxdt_financialaccounttransactionname = null;
639                
640                Long finatrxdt_fina_financialaccountid = rs.getLong(FINATRXDT_FINA_FINANCIALACCOUNTID);
641                if(rs.wasNull())
642                    finatrxdt_fina_financialaccountid = null;
643                
644                Long finatrxdt_fnatrxtyp_financialaccounttransactiontypeid = rs.getLong(FINATRXDT_FNATRXTYP_FINANCIALACCOUNTTRANSACTIONTYPEID);
645                if(rs.wasNull())
646                    finatrxdt_fnatrxtyp_financialaccounttransactiontypeid = null;
647                
648                Long finatrxdt_amount = rs.getLong(FINATRXDT_AMOUNT);
649                if(rs.wasNull())
650                    finatrxdt_amount = null;
651                
652                String finatrxdt_comment = rs.getString(FINATRXDT_COMMENT);
653                if(rs.wasNull())
654                    finatrxdt_comment = null;
655                
656                Long finatrxdt_fromtime = rs.getLong(FINATRXDT_FROMTIME);
657                if(rs.wasNull())
658                    finatrxdt_fromtime = null;
659                
660                Long finatrxdt_thrutime = rs.getLong(FINATRXDT_THRUTIME);
661                if(rs.wasNull())
662                    finatrxdt_thrutime = null;
663                
664                FinancialAccountTransactionDetailValue _value = new FinancialAccountTransactionDetailValue(_pk, finatrxdt_finatrx_financialaccounttransactionid == null? null: new FinancialAccountTransactionPK(finatrxdt_finatrx_financialaccounttransactionid), finatrxdt_financialaccounttransactionname, finatrxdt_fina_financialaccountid == null? null: new FinancialAccountPK(finatrxdt_fina_financialaccountid), finatrxdt_fnatrxtyp_financialaccounttransactiontypeid == null? null: new FinancialAccountTransactionTypePK(finatrxdt_fnatrxtyp_financialaccounttransactiontypeid), finatrxdt_amount, finatrxdt_comment, finatrxdt_fromtime, finatrxdt_thrutime);
665                _entity = new FinancialAccountTransactionDetail(_value, entityPermission);
666            }
667            
668            if(!foundInSessionCache) {
669                if(entityPermission.equals(EntityPermission.READ_ONLY)) {
670                    session.putReadOnlyEntity(_pk, _entity);
671                    session.getValueCache().put(_entity.getFinancialAccountTransactionDetailValue());
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 FinancialAccountTransactionDetail create(Session session, FinancialAccountTransaction financialAccountTransaction, String financialAccountTransactionName, FinancialAccount financialAccount, FinancialAccountTransactionType financialAccountTransactionType, Long amount, String comment, Long fromTime, Long thruTime)
684            throws PersistenceDatabaseException, PersistenceNotNullException {
685        return create(session, financialAccountTransaction == null ? null : financialAccountTransaction.getPrimaryKey(), financialAccountTransactionName, financialAccount == null ? null : financialAccount.getPrimaryKey(), financialAccountTransactionType == null ? null : financialAccountTransactionType.getPrimaryKey(), amount, comment, fromTime, thruTime);
686    }
687    
688    public FinancialAccountTransactionDetail create(FinancialAccountTransaction financialAccountTransaction, String financialAccountTransactionName, FinancialAccount financialAccount, FinancialAccountTransactionType financialAccountTransactionType, Long amount, String comment, Long fromTime, Long thruTime)
689            throws PersistenceDatabaseException, PersistenceNotNullException {
690        return create(ThreadSession.currentSession(), financialAccountTransaction == null ? null : financialAccountTransaction.getPrimaryKey(), financialAccountTransactionName, financialAccount == null ? null : financialAccount.getPrimaryKey(), financialAccountTransactionType == null ? null : financialAccountTransactionType.getPrimaryKey(), amount, comment, fromTime, thruTime);
691    }
692    
693    private void bindForCreate(PreparedStatement _ps, FinancialAccountTransactionDetailValue _value)
694            throws SQLException {
695        _ps.setLong(1, _value.getEntityId());
696        
697        FinancialAccountTransactionPK finatrxdt_finatrx_financialaccounttransactionid = _value.getFinancialAccountTransactionPK();
698        if(finatrxdt_finatrx_financialaccounttransactionid == null)
699            _ps.setNull(2, Types.BIGINT);
700        else
701            _ps.setLong(2, finatrxdt_finatrx_financialaccounttransactionid.getEntityId());
702            
703        String finatrxdt_financialaccounttransactionname = _value.getFinancialAccountTransactionName();
704        if(finatrxdt_financialaccounttransactionname == null)
705            _ps.setNull(3, Types.VARCHAR);
706        else
707            _ps.setString(3, finatrxdt_financialaccounttransactionname);
708            
709        FinancialAccountPK finatrxdt_fina_financialaccountid = _value.getFinancialAccountPK();
710        if(finatrxdt_fina_financialaccountid == null)
711            _ps.setNull(4, Types.BIGINT);
712        else
713            _ps.setLong(4, finatrxdt_fina_financialaccountid.getEntityId());
714            
715        FinancialAccountTransactionTypePK finatrxdt_fnatrxtyp_financialaccounttransactiontypeid = _value.getFinancialAccountTransactionTypePK();
716        if(finatrxdt_fnatrxtyp_financialaccounttransactiontypeid == null)
717            _ps.setNull(5, Types.BIGINT);
718        else
719            _ps.setLong(5, finatrxdt_fnatrxtyp_financialaccounttransactiontypeid.getEntityId());
720            
721        Long finatrxdt_amount = _value.getAmount();
722        if(finatrxdt_amount == null)
723            _ps.setNull(6, Types.BIGINT);
724        else
725            _ps.setLong(6, finatrxdt_amount);
726            
727        String finatrxdt_comment = _value.getComment();
728        if(finatrxdt_comment == null)
729            _ps.setNull(7, Types.VARCHAR);
730        else
731            _ps.setString(7, finatrxdt_comment);
732            
733        Long finatrxdt_fromtime = _value.getFromTime();
734        if(finatrxdt_fromtime == null)
735            _ps.setNull(8, Types.BIGINT);
736        else
737            _ps.setLong(8, finatrxdt_fromtime);
738            
739        Long finatrxdt_thrutime = _value.getThruTime();
740        if(finatrxdt_thrutime == null)
741            _ps.setNull(9, Types.BIGINT);
742        else
743            _ps.setLong(9, finatrxdt_thrutime);
744            
745    }
746    
747    public FinancialAccountTransactionDetail create(Session session, FinancialAccountTransactionPK financialAccountTransactionPK, String financialAccountTransactionName, FinancialAccountPK financialAccountPK, FinancialAccountTransactionTypePK financialAccountTransactionTypePK, Long amount, String comment, Long fromTime, Long thruTime)
748            throws PersistenceDatabaseException, PersistenceNotNullException {
749        FinancialAccountTransactionDetailPK _pk = getNextPK();
750        FinancialAccountTransactionDetailValue _value = new FinancialAccountTransactionDetailValue(_pk, financialAccountTransactionPK, financialAccountTransactionName, financialAccountPK, financialAccountTransactionTypePK, amount, comment, 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        FinancialAccountTransactionDetail _entity = new FinancialAccountTransactionDetail(_value, EntityPermission.READ_ONLY);
773        session.putReadOnlyEntity(_pk, _entity);
774        
775        return _entity;
776    }
777    
778    public FinancialAccountTransactionDetail create(FinancialAccountTransactionPK financialAccountTransactionPK, String financialAccountTransactionName, FinancialAccountPK financialAccountPK, FinancialAccountTransactionTypePK financialAccountTransactionTypePK, Long amount, String comment, Long fromTime, Long thruTime)
779            throws PersistenceDatabaseException, PersistenceNotNullException {
780        return create(ThreadSession.currentSession(), financialAccountTransactionPK, financialAccountTransactionName, financialAccountPK, financialAccountTransactionTypePK, amount, comment, fromTime, thruTime);
781    }
782    
783    public void create(Session session, Collection<FinancialAccountTransactionDetailValue> _values)
784            throws PersistenceDatabaseException, PersistenceNotNullException {
785        int _size = _values.size();
786        
787        if(_size > 0) {
788            PreparedStatement _ps = session.prepareStatement(SQL_INSERT);
789            List<FinancialAccountTransactionDetailValue> _cacheValues = new ArrayList<>(_size);
790            
791            try {
792                for(FinancialAccountTransactionDetailValue _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                FinancialAccountTransactionDetail _cacheEntity = new FinancialAccountTransactionDetail(_cacheValue, EntityPermission.READ_ONLY);
820                
821                session.putReadOnlyEntity(_cacheValue.getPrimaryKey(), _cacheEntity);
822            });
823        }
824    }
825    
826    public void create(Collection<FinancialAccountTransactionDetailValue> _values)
827            throws PersistenceDatabaseException, PersistenceNotNullException {
828        create(ThreadSession.currentSession(), _values);
829    }
830    
831    private boolean bindForStore(PreparedStatement _ps, FinancialAccountTransactionDetailValue _value)
832            throws SQLException {
833        boolean _hasBeenModified = _value.hasBeenModified();
834        
835        if(_hasBeenModified) {
836            FinancialAccountTransactionPK finatrxdt_finatrx_financialaccounttransactionid = _value.getFinancialAccountTransactionPK();
837            if(finatrxdt_finatrx_financialaccounttransactionid == null)
838                _ps.setNull(1, Types.BIGINT);
839            else
840                _ps.setLong(1, finatrxdt_finatrx_financialaccounttransactionid.getEntityId());
841            
842            String finatrxdt_financialaccounttransactionname = _value.getFinancialAccountTransactionName();
843            if(finatrxdt_financialaccounttransactionname == null)
844                _ps.setNull(2, Types.VARCHAR);
845            else
846                _ps.setString(2, finatrxdt_financialaccounttransactionname);
847            
848            FinancialAccountPK finatrxdt_fina_financialaccountid = _value.getFinancialAccountPK();
849            if(finatrxdt_fina_financialaccountid == null)
850                _ps.setNull(3, Types.BIGINT);
851            else
852                _ps.setLong(3, finatrxdt_fina_financialaccountid.getEntityId());
853            
854            FinancialAccountTransactionTypePK finatrxdt_fnatrxtyp_financialaccounttransactiontypeid = _value.getFinancialAccountTransactionTypePK();
855            if(finatrxdt_fnatrxtyp_financialaccounttransactiontypeid == null)
856                _ps.setNull(4, Types.BIGINT);
857            else
858                _ps.setLong(4, finatrxdt_fnatrxtyp_financialaccounttransactiontypeid.getEntityId());
859            
860            Long finatrxdt_amount = _value.getAmount();
861            if(finatrxdt_amount == null)
862                _ps.setNull(5, Types.BIGINT);
863            else
864                _ps.setLong(5, finatrxdt_amount);
865            
866            String finatrxdt_comment = _value.getComment();
867            if(finatrxdt_comment == null)
868                _ps.setNull(6, Types.VARCHAR);
869            else
870                _ps.setString(6, finatrxdt_comment);
871            
872            Long finatrxdt_fromtime = _value.getFromTime();
873            if(finatrxdt_fromtime == null)
874                _ps.setNull(7, Types.BIGINT);
875            else
876                _ps.setLong(7, finatrxdt_fromtime);
877            
878            Long finatrxdt_thrutime = _value.getThruTime();
879            if(finatrxdt_thrutime == null)
880                _ps.setNull(8, Types.BIGINT);
881            else
882                _ps.setLong(8, finatrxdt_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, FinancialAccountTransactionDetail entity)
894            throws PersistenceDatabaseException {
895        PreparedStatement _ps = session.prepareStatement(SQL_UPDATE);
896        
897        try {
898            FinancialAccountTransactionDetailValue _value = entity.getFinancialAccountTransactionDetailValue();
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<FinancialAccountTransactionDetail> 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(FinancialAccountTransactionDetail entity : entities) {
927                    if(bindForStore(_ps, entity.getFinancialAccountTransactionDetailValue())) {
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.getFinancialAccountTransactionDetailValue());
950                    });
951                }
952            } catch (SQLException se) {
953                throw new PersistenceDatabaseException(se);
954            }
955        }
956    }
957    
958    @Override
959    public void store(Collection<FinancialAccountTransactionDetail> entities)
960            throws PersistenceDatabaseException {
961        store(ThreadSession.currentSession(), entities);
962    }
963    
964    @Override
965    public void remove(Session session, FinancialAccountTransactionDetail entity)
966            throws PersistenceDatabaseException {
967        remove(session, entity.getPrimaryKey());
968    }
969    
970    @Override
971    public void remove(Session session, FinancialAccountTransactionDetailPK 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<FinancialAccountTransactionDetailPK> 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(FinancialAccountTransactionDetailPK 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<FinancialAccountTransactionDetailPK> pks)
1045            throws PersistenceDatabaseException {
1046        remove(ThreadSession.currentSession(), pks);
1047    }
1048    
1049    @Override
1050    public boolean validPK(Session session, FinancialAccountTransactionDetailPK 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}