Source code

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