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