// --------------------------------------------------------------------------------
// Copyright 2002-2025 Echo Three, LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// --------------------------------------------------------------------------------
// Generated File -- DO NOT EDIT BY HAND
// --------------------------------------------------------------------------------

/**
 * PaymentProcessorResultCodeDescriptionFactory.java
 */

package com.echothree.model.data.payment.server.factory;

import com.echothree.model.data.payment.common.pk.PaymentProcessorResultCodePK;
import com.echothree.model.data.party.common.pk.LanguagePK;

import com.echothree.model.data.payment.server.entity.PaymentProcessorResultCode;
import com.echothree.model.data.party.server.entity.Language;

import com.echothree.model.data.payment.common.PaymentProcessorResultCodeDescriptionConstants;
import com.echothree.model.data.payment.common.pk.PaymentProcessorResultCodeDescriptionPK;
import com.echothree.model.data.payment.server.value.PaymentProcessorResultCodeDescriptionValue;
import com.echothree.model.data.payment.server.entity.PaymentProcessorResultCodeDescription;
import com.echothree.util.common.exception.PersistenceDatabaseException;
import com.echothree.util.common.exception.PersistenceDatabaseUpdateException;
import com.echothree.util.common.exception.PersistenceNotNullException;
import com.echothree.util.server.persistence.BaseFactory;
import com.echothree.util.server.persistence.EntityIdGenerator;
import com.echothree.util.server.persistence.EntityPermission;
import com.echothree.util.server.persistence.PersistenceDebugFlags;
import com.echothree.util.server.persistence.Session;
import com.echothree.util.server.persistence.ThreadSession;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;
import java.io.ByteArrayInputStream;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.enterprise.context.ApplicationScoped;
import javax.enterprise.inject.spi.CDI;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

@ApplicationScoped
public class PaymentProcessorResultCodeDescriptionFactory
        implements BaseFactory<PaymentProcessorResultCodeDescriptionPK, PaymentProcessorResultCodeDescription> {
    
    //final private static Log log = LogFactory.getLog(PaymentProcessorResultCodeDescriptionFactory.class);
    
    final private static String SQL_SELECT_READ_ONLY = "SELECT pprcrcd_paymentprocessorresultcodedescriptionid, pprcrcd_pprcrc_paymentprocessorresultcodeid, pprcrcd_lang_languageid, pprcrcd_description, pprcrcd_fromtime, pprcrcd_thrutime FROM paymentprocessorresultcodedescriptions WHERE pprcrcd_paymentprocessorresultcodedescriptionid = ?";
    final private static String SQL_SELECT_READ_WRITE = "SELECT pprcrcd_paymentprocessorresultcodedescriptionid, pprcrcd_pprcrc_paymentprocessorresultcodeid, pprcrcd_lang_languageid, pprcrcd_description, pprcrcd_fromtime, pprcrcd_thrutime FROM paymentprocessorresultcodedescriptions WHERE pprcrcd_paymentprocessorresultcodedescriptionid = ? FOR UPDATE";
    final private static String SQL_INSERT = "INSERT INTO paymentprocessorresultcodedescriptions (pprcrcd_paymentprocessorresultcodedescriptionid, pprcrcd_pprcrc_paymentprocessorresultcodeid, pprcrcd_lang_languageid, pprcrcd_description, pprcrcd_fromtime, pprcrcd_thrutime) VALUES (?, ?, ?, ?, ?, ?)";
    final private static String SQL_UPDATE = "UPDATE paymentprocessorresultcodedescriptions SET pprcrcd_pprcrc_paymentprocessorresultcodeid = ?, pprcrcd_lang_languageid = ?, pprcrcd_description = ?, pprcrcd_fromtime = ?, pprcrcd_thrutime = ? WHERE pprcrcd_paymentprocessorresultcodedescriptionid = ?";
    final private static String SQL_DELETE = "DELETE FROM paymentprocessorresultcodedescriptions WHERE pprcrcd_paymentprocessorresultcodedescriptionid = ?";
    final private static String SQL_VALID = "SELECT COUNT(*) FROM paymentprocessorresultcodedescriptions WHERE pprcrcd_paymentprocessorresultcodedescriptionid = ?";
    
    final private static String PK_COLUMN = "pprcrcd_paymentprocessorresultcodedescriptionid";
    final private static String ALL_COLUMNS = "pprcrcd_paymentprocessorresultcodedescriptionid, pprcrcd_pprcrc_paymentprocessorresultcodeid, pprcrcd_lang_languageid, pprcrcd_description, pprcrcd_fromtime, pprcrcd_thrutime";
    final public static String TABLE_NAME = "paymentprocessorresultcodedescriptions";
    
    final public static String PPRCRCD_PAYMENTPROCESSORRESULTCODEDESCRIPTIONID = "pprcrcd_paymentprocessorresultcodedescriptionid";
    final public static String PPRCRCD_PPRCRC_PAYMENTPROCESSORRESULTCODEID = "pprcrcd_pprcrc_paymentprocessorresultcodeid";
    final public static String PPRCRCD_LANG_LANGUAGEID = "pprcrcd_lang_languageid";
    final public static String PPRCRCD_DESCRIPTION = "pprcrcd_description";
    final public static String PPRCRCD_FROMTIME = "pprcrcd_fromtime";
    final public static String PPRCRCD_THRUTIME = "pprcrcd_thrutime";
    
    final private static EntityIdGenerator entityIdGenerator = new EntityIdGenerator(PaymentProcessorResultCodeDescriptionConstants.COMPONENT_VENDOR_NAME, PaymentProcessorResultCodeDescriptionConstants.ENTITY_TYPE_NAME);
    
    /** Creates a new instance of PaymentProcessorResultCodeDescriptionFactory */
    protected PaymentProcessorResultCodeDescriptionFactory() {
        super();
    }
    
    public static PaymentProcessorResultCodeDescriptionFactory getInstance() {
        return CDI.current().select(PaymentProcessorResultCodeDescriptionFactory.class).get();
    }
    
    @Override
    public String getPKColumn() {
        return PK_COLUMN;
    }
    
    @Override
    public String getAllColumns() {
        return ALL_COLUMNS;
    }
    
    @Override
    public String getTableName() {
        return TABLE_NAME;
    }
    
    @Override
    public String getComponentVendorName() {
        return PaymentProcessorResultCodeDescriptionConstants.COMPONENT_VENDOR_NAME;
    }
    
    @Override
    public String getEntityTypeName() {
        return PaymentProcessorResultCodeDescriptionConstants.ENTITY_TYPE_NAME;
    }
    
    public PreparedStatement prepareStatement(String query) {
        return ThreadSession.currentSession().prepareStatement(PaymentProcessorResultCodeDescriptionFactory.class, query);
    }
    
    public PaymentProcessorResultCodeDescriptionPK getNextPK() {
        return new PaymentProcessorResultCodeDescriptionPK(entityIdGenerator.getNextEntityId());
    }
    
    public Set<PaymentProcessorResultCodeDescriptionPK> getPKsFromResultSetAsSet(ResultSet rs)
            throws PersistenceDatabaseException {
        Set<PaymentProcessorResultCodeDescriptionPK> _result = new HashSet<>();
        
        try {
            while(rs.next()) {
                _result.add(getPKFromResultSet(rs));
            }
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
        
        return _result;
    }
    
    public java.util.List<PaymentProcessorResultCodeDescriptionPK> getPKsFromResultSetAsList(ResultSet rs)
            throws PersistenceDatabaseException {
        java.util.List<PaymentProcessorResultCodeDescriptionPK> _result = new ArrayList<>();
        
        try {
            while(rs.next()) {
                _result.add(getPKFromResultSet(rs));
            }
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
        
        return _result;
    }
    
    public PaymentProcessorResultCodeDescriptionPK getPKFromResultSet(ResultSet rs)
            throws PersistenceDatabaseException {
        PaymentProcessorResultCodeDescriptionPK _result;
        
        try {
            long pprcrcd_paymentprocessorresultcodedescriptionid = rs.getLong(PPRCRCD_PAYMENTPROCESSORRESULTCODEDESCRIPTIONID);
            Long _entityId = rs.wasNull() ? null : pprcrcd_paymentprocessorresultcodedescriptionid;
            
            _result = new PaymentProcessorResultCodeDescriptionPK(_entityId);
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
        
        return _result;
    }
    
    public java.util.List<PaymentProcessorResultCodeDescriptionValue> getValuesFromPKs(Session session, Collection<PaymentProcessorResultCodeDescriptionPK> pks)
            throws PersistenceDatabaseException {
        java.util.List<PaymentProcessorResultCodeDescriptionValue> _values = new ArrayList<>(pks.size());
        
        for(PaymentProcessorResultCodeDescriptionPK _pk: pks) {
            _values.add(getValueFromPK(session, _pk));
        }
        
        return _values;
    }
    
    public PaymentProcessorResultCodeDescriptionValue getValueFromPK(Session session, PaymentProcessorResultCodeDescriptionPK pk)
            throws PersistenceDatabaseException {
        PaymentProcessorResultCodeDescriptionValue _value;
        
        // See if we already have the entity in the session cache
        PaymentProcessorResultCodeDescription _entity = (PaymentProcessorResultCodeDescription)session.getEntity(pk);
        if(_entity == null)
            _value = getEntityFromPK(session, EntityPermission.READ_ONLY, pk).getPaymentProcessorResultCodeDescriptionValue();
        else
            _value = _entity.getPaymentProcessorResultCodeDescriptionValue();
        
        return _value;
    }
    
    public java.util.List<PaymentProcessorResultCodeDescriptionValue> getValuesFromResultSet(Session session, ResultSet rs)
            throws PersistenceDatabaseException {
        java.util.List<PaymentProcessorResultCodeDescriptionValue> _result = new ArrayList<>();
        
        try {
            while(rs.next()) {
                _result.add(getValueFromResultSet(session, rs));
            }
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
        
        return _result;
    }
    
    public PaymentProcessorResultCodeDescriptionValue getValueFromResultSet(Session session, ResultSet rs)
            throws PersistenceDatabaseException {
        PaymentProcessorResultCodeDescriptionValue _value;
        
        try {
            Long pprcrcd_paymentprocessorresultcodedescriptionid = rs.getLong(PPRCRCD_PAYMENTPROCESSORRESULTCODEDESCRIPTIONID);
            PaymentProcessorResultCodeDescriptionPK _pk = new PaymentProcessorResultCodeDescriptionPK(pprcrcd_paymentprocessorresultcodedescriptionid);
            
            // See if we already have the entity in the session cache
            PaymentProcessorResultCodeDescription _entity = (PaymentProcessorResultCodeDescription)session.getEntity(_pk);
            
            if(_entity == null) {
                Long pprcrcd_pprcrc_paymentprocessorresultcodeid = rs.getLong(PPRCRCD_PPRCRC_PAYMENTPROCESSORRESULTCODEID);
                if(rs.wasNull())
                    pprcrcd_pprcrc_paymentprocessorresultcodeid = null;
                
                Long pprcrcd_lang_languageid = rs.getLong(PPRCRCD_LANG_LANGUAGEID);
                if(rs.wasNull())
                    pprcrcd_lang_languageid = null;
                
                String pprcrcd_description = rs.getString(PPRCRCD_DESCRIPTION);
                if(rs.wasNull())
                    pprcrcd_description = null;
                
                Long pprcrcd_fromtime = rs.getLong(PPRCRCD_FROMTIME);
                if(rs.wasNull())
                    pprcrcd_fromtime = null;
                
                Long pprcrcd_thrutime = rs.getLong(PPRCRCD_THRUTIME);
                if(rs.wasNull())
                    pprcrcd_thrutime = null;
                
                _value = new PaymentProcessorResultCodeDescriptionValue(_pk, new PaymentProcessorResultCodePK(pprcrcd_pprcrc_paymentprocessorresultcodeid), new LanguagePK(pprcrcd_lang_languageid), pprcrcd_description, pprcrcd_fromtime, pprcrcd_thrutime);
            } else
                _value = _entity.getPaymentProcessorResultCodeDescriptionValue();
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
        
        return _value;
    }
    
    public java.util.List<PaymentProcessorResultCodeDescription> getEntitiesFromPKs(EntityPermission entityPermission, Collection<PaymentProcessorResultCodeDescriptionPK> pks)
            throws PersistenceDatabaseException {
        return getEntitiesFromPKs(ThreadSession.currentSession(), entityPermission, pks);
    }
    
    public java.util.List<PaymentProcessorResultCodeDescription> getEntitiesFromPKs(Session session, EntityPermission entityPermission, Collection<PaymentProcessorResultCodeDescriptionPK> pks)
            throws PersistenceDatabaseException {
        java.util.List<PaymentProcessorResultCodeDescription> _entities = new ArrayList<>(pks.size());
        
        for(PaymentProcessorResultCodeDescriptionPK _pk: pks) {
            _entities.add(getEntityFromPK(session, entityPermission, _pk));
        }
        
        return _entities;
    }
    
    public PaymentProcessorResultCodeDescription getEntityFromValue(EntityPermission entityPermission, PaymentProcessorResultCodeDescriptionValue value) {
        return getEntityFromPK(ThreadSession.currentSession(), entityPermission, value.getPrimaryKey());
    }
    
    public PaymentProcessorResultCodeDescription getEntityFromValue(Session session, EntityPermission entityPermission, PaymentProcessorResultCodeDescriptionValue value) {
        return getEntityFromPK(session, entityPermission, value.getPrimaryKey());
    }
    
    public PaymentProcessorResultCodeDescription getEntityFromPK(EntityPermission entityPermission, PaymentProcessorResultCodeDescriptionPK pk)
            throws PersistenceDatabaseException {
        return getEntityFromPK(ThreadSession.currentSession(), entityPermission, pk);
    }
    
    public PaymentProcessorResultCodeDescription getEntityFromCache(Session session, PaymentProcessorResultCodeDescriptionPK pk) {
        PaymentProcessorResultCodeDescriptionValue _value = (PaymentProcessorResultCodeDescriptionValue)session.getValueCache().get(pk);
    
        return _value == null ? null : new PaymentProcessorResultCodeDescription(_value, EntityPermission.READ_ONLY);
    }
    
    public PaymentProcessorResultCodeDescription getEntityFromPK(Session session, EntityPermission entityPermission, PaymentProcessorResultCodeDescriptionPK pk)
            throws PersistenceDatabaseException {
        PaymentProcessorResultCodeDescription _entity;
        
        // See if we already have the entity in the session cache
        _entity = (PaymentProcessorResultCodeDescription)session.getEntity(pk);
        if(_entity != null) {
            // If the requested permission is READ_WRITE, and the cached permission is
            // READ_ONLY, then pretend that the cached object wasn't found, and create
            // a new entity that is READ_WRITE.
            if(entityPermission.equals(EntityPermission.READ_WRITE)) {
                if(_entity.getEntityPermission().equals(EntityPermission.READ_ONLY))
                    _entity = null;
            }
        }
        
        if(_entity == null && entityPermission.equals(EntityPermission.READ_ONLY)) {
            _entity = getEntityFromCache(session, pk);
        }
        
        if(_entity == null) {
            PreparedStatement _ps = session.prepareStatement(entityPermission.equals(EntityPermission.READ_ONLY)? SQL_SELECT_READ_ONLY: SQL_SELECT_READ_WRITE);
            long _entityId = pk.getEntityId();
            ResultSet _rs = null;
            
            try {
                _ps.setLong(1, _entityId);
                _rs = _ps.executeQuery();
                if(_rs.next()) {
                    _entity = getEntityFromResultSet(session, entityPermission, _rs);
                }
            } catch (SQLException se) {
                throw new PersistenceDatabaseException(se);
            } finally {
                if(_rs != null) {
                    try {
                        _rs.close();
                    } catch (SQLException se) {
                        // do nothing
                    }
                }
            }
        }
        
        return _entity;
    }
    
    public Set<PaymentProcessorResultCodeDescriptionPK> getPKsFromQueryAsSet(PreparedStatement ps, final Object... params)
            throws PersistenceDatabaseException {
        Set<PaymentProcessorResultCodeDescriptionPK> _pks;
        ResultSet _rs = null;
        
        try {
            if(params.length != 0) {
                Session.setQueryParams(ps, params);
            }
            
            _rs = ps.executeQuery();
            _pks = getPKsFromResultSetAsSet(_rs);
            _rs.close();
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        } finally {
            if(_rs != null) {
                try {
                    _rs.close();
                } catch (SQLException se) {
                    // do nothing
                }
            }
        }
        
        return _pks;
    }
    
    public java.util.List<PaymentProcessorResultCodeDescriptionPK> getPKsFromQueryAsList(PreparedStatement ps, final Object... params)
            throws PersistenceDatabaseException {
        java.util.List<PaymentProcessorResultCodeDescriptionPK> _pks;
        ResultSet _rs = null;
        
        try {
            if(params.length != 0) {
                Session.setQueryParams(ps, params);
            }
            
            _rs = ps.executeQuery();
            _pks = getPKsFromResultSetAsList(_rs);
            _rs.close();
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        } finally {
            if(_rs != null) {
                try {
                    _rs.close();
                } catch (SQLException se) {
                    // do nothing
                }
            }
        }
        
        return _pks;
    }
    
    public PaymentProcessorResultCodeDescriptionPK getPKFromQuery(PreparedStatement ps, final Object... params)
            throws PersistenceDatabaseException {
        PaymentProcessorResultCodeDescriptionPK _pk = null;
        ResultSet _rs = null;
        
        try {
            if(params.length != 0) {
                Session.setQueryParams(ps, params);
            }
            
            _rs = ps.executeQuery();
            if(_rs.next()) {
                _pk = getPKFromResultSet(_rs);
            }
            _rs.close();
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        } finally {
            if(_rs != null) {
                try {
                    _rs.close();
                } catch (SQLException se) {
                    // do nothing
                }
            }
        }
        
        return _pk;
    }
    
    public java.util.List<PaymentProcessorResultCodeDescription> getEntitiesFromQuery(Session session, EntityPermission entityPermission, Map<EntityPermission, String>queryMap, final Object... params)
            throws PersistenceDatabaseException {
        PreparedStatement ps = session.prepareStatement(PaymentProcessorResultCodeDescriptionFactory.class, queryMap.get(entityPermission));
        
        return getEntitiesFromQuery(session, entityPermission, ps, params);
    }
    
    public java.util.List<PaymentProcessorResultCodeDescription> getEntitiesFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap, final Object... params)
            throws PersistenceDatabaseException {
        Session session = ThreadSession.currentSession();
        PreparedStatement ps = session.prepareStatement(PaymentProcessorResultCodeDescriptionFactory.class, queryMap.get(entityPermission));
        
        return getEntitiesFromQuery(session, entityPermission, ps, params);
    }
    
    public java.util.List<PaymentProcessorResultCodeDescription> getEntitiesFromQuery(Session session, EntityPermission entityPermission, Map<EntityPermission, String>queryMap)
            throws PersistenceDatabaseException {
        PreparedStatement ps = session.prepareStatement(PaymentProcessorResultCodeDescriptionFactory.class, queryMap.get(entityPermission));
        
        return getEntitiesFromQuery(session, entityPermission, ps);
    }
    
    public java.util.List<PaymentProcessorResultCodeDescription> getEntitiesFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap)
            throws PersistenceDatabaseException {
        Session session = ThreadSession.currentSession();
        PreparedStatement ps = session.prepareStatement(PaymentProcessorResultCodeDescriptionFactory.class, queryMap.get(entityPermission));
        
        return getEntitiesFromQuery(session, entityPermission, ps);
    }
    
    public java.util.List<PaymentProcessorResultCodeDescription> getEntitiesFromQuery(EntityPermission entityPermission, PreparedStatement ps)
            throws PersistenceDatabaseException {
        return getEntitiesFromQuery(ThreadSession.currentSession(), entityPermission, ps);
    }
    
    public java.util.List<PaymentProcessorResultCodeDescription> getEntitiesFromQuery(EntityPermission entityPermission, PreparedStatement ps, final Object... params)
            throws PersistenceDatabaseException {
        return getEntitiesFromQuery(ThreadSession.currentSession(), entityPermission, ps, params);
    }
    
    public java.util.List<PaymentProcessorResultCodeDescription> getEntitiesFromQuery(Session session, EntityPermission entityPermission, PreparedStatement ps, final Object... params)
            throws PersistenceDatabaseException {
        java.util.List<PaymentProcessorResultCodeDescription> _entities;
        ResultSet _rs = null;
        
        try {
            if(params.length != 0) {
                Session.setQueryParams(ps, params);
            }
            
            _rs = ps.executeQuery();
            _entities = getEntitiesFromResultSet(session, entityPermission, _rs);
            _rs.close();
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        } finally {
            if(_rs != null) {
                try {
                    _rs.close();
                } catch (SQLException se) {
                    // do nothing
                }
            }
        }
        
        return _entities;
    }
    
    public PaymentProcessorResultCodeDescription getEntityFromQuery(Session session, EntityPermission entityPermission, Map<EntityPermission, String>queryMap, final Object... params)
            throws PersistenceDatabaseException {
        PreparedStatement ps = session.prepareStatement(PaymentProcessorResultCodeDescriptionFactory.class, queryMap.get(entityPermission));
        
        return getEntityFromQuery(session, entityPermission, ps, params);
    }
    
    public PaymentProcessorResultCodeDescription getEntityFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap, final Object... params)
            throws PersistenceDatabaseException {
        Session session = ThreadSession.currentSession();
        PreparedStatement ps = session.prepareStatement(PaymentProcessorResultCodeDescriptionFactory.class, queryMap.get(entityPermission));
        
        return getEntityFromQuery(session, entityPermission, ps, params);
    }
    
    public PaymentProcessorResultCodeDescription getEntityFromQuery(Session session, EntityPermission entityPermission, Map<EntityPermission, String>queryMap)
            throws PersistenceDatabaseException {
        PreparedStatement ps = session.prepareStatement(PaymentProcessorResultCodeDescriptionFactory.class, queryMap.get(entityPermission));
        
        return getEntityFromQuery(session, entityPermission, ps);
    }
    
    public PaymentProcessorResultCodeDescription getEntityFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap)
            throws PersistenceDatabaseException {
        Session session = ThreadSession.currentSession();
        PreparedStatement ps = session.prepareStatement(PaymentProcessorResultCodeDescriptionFactory.class, queryMap.get(entityPermission));
        
        return getEntityFromQuery(session, entityPermission, ps);
    }
    
    public PaymentProcessorResultCodeDescription getEntityFromQuery(EntityPermission entityPermission, PreparedStatement ps)
            throws PersistenceDatabaseException {
        return getEntityFromQuery(ThreadSession.currentSession(), entityPermission, ps);
    }
    
    public PaymentProcessorResultCodeDescription getEntityFromQuery(EntityPermission entityPermission, PreparedStatement ps, final Object... params)
            throws PersistenceDatabaseException {
        return getEntityFromQuery(ThreadSession.currentSession(), entityPermission, ps, params);
    }
    
    public PaymentProcessorResultCodeDescription getEntityFromQuery(Session session, EntityPermission entityPermission, PreparedStatement ps, final Object... params)
            throws PersistenceDatabaseException {
        PaymentProcessorResultCodeDescription _entity = null;
        ResultSet _rs = null;
        
        try {
            if(params.length != 0) {
                Session.setQueryParams(ps, params);
            }
            
            _rs = ps.executeQuery();
            if(_rs.next()) {
                _entity = getEntityFromResultSet(session, entityPermission, _rs);
            }
            _rs.close();
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        } finally {
            if(_rs != null) {
                try {
                    _rs.close();
                } catch (SQLException se) {
                    // do nothing
                }
            }
        }
        
        return _entity;
    }
    
    public java.util.List<PaymentProcessorResultCodeDescription> getEntitiesFromResultSet(EntityPermission entityPermission, ResultSet rs)
            throws PersistenceDatabaseException {
        return getEntitiesFromResultSet(ThreadSession.currentSession(), entityPermission, rs);
    }
    
    public java.util.List<PaymentProcessorResultCodeDescription> getEntitiesFromResultSet(Session session, EntityPermission entityPermission, ResultSet rs)
            throws PersistenceDatabaseException {
        java.util.List<PaymentProcessorResultCodeDescription> _result = new ArrayList<>();
        
        try {
            while(rs.next()) {
                _result.add(getEntityFromResultSet(session, entityPermission, rs));
            }
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
        
        return _result;
    }
    
    public PaymentProcessorResultCodeDescription getEntityFromResultSet(EntityPermission entityPermission, ResultSet rs)
            throws PersistenceDatabaseException {
        return getEntityFromResultSet(ThreadSession.currentSession(), entityPermission, rs);
    }
    
    public PaymentProcessorResultCodeDescription getEntityFromResultSet(Session session, EntityPermission entityPermission, ResultSet rs)
            throws PersistenceDatabaseException {
        PaymentProcessorResultCodeDescription _entity;
        
        try {
            Long pprcrcd_paymentprocessorresultcodedescriptionid = rs.getLong(PPRCRCD_PAYMENTPROCESSORRESULTCODEDESCRIPTIONID);
            PaymentProcessorResultCodeDescriptionPK _pk = new PaymentProcessorResultCodeDescriptionPK(pprcrcd_paymentprocessorresultcodedescriptionid);
            
            // See if we already have the entity in the session cache
            _entity = (PaymentProcessorResultCodeDescription)session.getEntity(_pk);
            if(_entity != null) {
                // If the requested permission is READ_WRITE, and the cached permission is
                // READ_ONLY, then pretend that the cached object wasn't found, and create
                // a new entity that is READ_WRITE.
                if(entityPermission.equals(EntityPermission.READ_WRITE)) {
                    if(_entity.getEntityPermission().equals(EntityPermission.READ_ONLY))
                        _entity = null;
                }
            }
            boolean foundInSessionCache = _entity != null;
            
            if(_entity == null && entityPermission.equals(EntityPermission.READ_ONLY)) {
                _entity = getEntityFromCache(session, _pk);
            }
            
            if(_entity == null) {
                Long pprcrcd_pprcrc_paymentprocessorresultcodeid = rs.getLong(PPRCRCD_PPRCRC_PAYMENTPROCESSORRESULTCODEID);
                if(rs.wasNull())
                    pprcrcd_pprcrc_paymentprocessorresultcodeid = null;
                
                Long pprcrcd_lang_languageid = rs.getLong(PPRCRCD_LANG_LANGUAGEID);
                if(rs.wasNull())
                    pprcrcd_lang_languageid = null;
                
                String pprcrcd_description = rs.getString(PPRCRCD_DESCRIPTION);
                if(rs.wasNull())
                    pprcrcd_description = null;
                
                Long pprcrcd_fromtime = rs.getLong(PPRCRCD_FROMTIME);
                if(rs.wasNull())
                    pprcrcd_fromtime = null;
                
                Long pprcrcd_thrutime = rs.getLong(PPRCRCD_THRUTIME);
                if(rs.wasNull())
                    pprcrcd_thrutime = null;
                
                PaymentProcessorResultCodeDescriptionValue _value = new PaymentProcessorResultCodeDescriptionValue(_pk, pprcrcd_pprcrc_paymentprocessorresultcodeid == null? null: new PaymentProcessorResultCodePK(pprcrcd_pprcrc_paymentprocessorresultcodeid), pprcrcd_lang_languageid == null? null: new LanguagePK(pprcrcd_lang_languageid), pprcrcd_description, pprcrcd_fromtime, pprcrcd_thrutime);
                _entity = new PaymentProcessorResultCodeDescription(_value, entityPermission);
            }
            
            if(!foundInSessionCache) {
                if(entityPermission.equals(EntityPermission.READ_ONLY)) {
                    session.putReadOnlyEntity(_pk, _entity);
                    session.getValueCache().put(_entity.getPaymentProcessorResultCodeDescriptionValue());
                } else {
                    session.putReadWriteEntity(_pk, _entity);
                }
            }
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
        
        return _entity;
    }
    
    public PaymentProcessorResultCodeDescription create(Session session, PaymentProcessorResultCode paymentProcessorResultCode, Language language, String description, Long fromTime, Long thruTime)
            throws PersistenceDatabaseException, PersistenceNotNullException {
        return create(session, paymentProcessorResultCode == null ? null : paymentProcessorResultCode.getPrimaryKey(), language == null ? null : language.getPrimaryKey(), description, fromTime, thruTime);
    }
    
    public PaymentProcessorResultCodeDescription create(PaymentProcessorResultCode paymentProcessorResultCode, Language language, String description, Long fromTime, Long thruTime)
            throws PersistenceDatabaseException, PersistenceNotNullException {
        return create(ThreadSession.currentSession(), paymentProcessorResultCode == null ? null : paymentProcessorResultCode.getPrimaryKey(), language == null ? null : language.getPrimaryKey(), description, fromTime, thruTime);
    }
    
    private void bindForCreate(PreparedStatement _ps, PaymentProcessorResultCodeDescriptionValue _value)
            throws SQLException {
        _ps.setLong(1, _value.getEntityId());
        
        PaymentProcessorResultCodePK pprcrcd_pprcrc_paymentprocessorresultcodeid = _value.getPaymentProcessorResultCodePK();
        if(pprcrcd_pprcrc_paymentprocessorresultcodeid == null)
            _ps.setNull(2, Types.BIGINT);
        else
            _ps.setLong(2, pprcrcd_pprcrc_paymentprocessorresultcodeid.getEntityId());
            
        LanguagePK pprcrcd_lang_languageid = _value.getLanguagePK();
        if(pprcrcd_lang_languageid == null)
            _ps.setNull(3, Types.BIGINT);
        else
            _ps.setLong(3, pprcrcd_lang_languageid.getEntityId());
            
        String pprcrcd_description = _value.getDescription();
        if(pprcrcd_description == null)
            _ps.setNull(4, Types.VARCHAR);
        else
            _ps.setString(4, pprcrcd_description);
            
        Long pprcrcd_fromtime = _value.getFromTime();
        if(pprcrcd_fromtime == null)
            _ps.setNull(5, Types.BIGINT);
        else
            _ps.setLong(5, pprcrcd_fromtime);
            
        Long pprcrcd_thrutime = _value.getThruTime();
        if(pprcrcd_thrutime == null)
            _ps.setNull(6, Types.BIGINT);
        else
            _ps.setLong(6, pprcrcd_thrutime);
            
    }
    
    public PaymentProcessorResultCodeDescription create(Session session, PaymentProcessorResultCodePK paymentProcessorResultCodePK, LanguagePK languagePK, String description, Long fromTime, Long thruTime)
            throws PersistenceDatabaseException, PersistenceNotNullException {
        PaymentProcessorResultCodeDescriptionPK _pk = getNextPK();
        PaymentProcessorResultCodeDescriptionValue _value = new PaymentProcessorResultCodeDescriptionValue(_pk, paymentProcessorResultCodePK, languagePK, description, fromTime, thruTime);
        
        PreparedStatement _ps = session.prepareStatement(SQL_INSERT);
        
        try {
            bindForCreate(_ps, _value);
            
            if(PersistenceDebugFlags.CheckEntityInsertRowCount) {
                int _count = _ps.executeUpdate();
                
                if(_count != 1) {
                    throw new PersistenceDatabaseUpdateException("insert failed, _count = " + _count);
                }
            } else {
                 _ps.executeUpdate();
            }
            
            session.getValueCache().put(_value);
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
        
        PaymentProcessorResultCodeDescription _entity = new PaymentProcessorResultCodeDescription(_value, EntityPermission.READ_ONLY);
        session.putReadOnlyEntity(_pk, _entity);
        
        return _entity;
    }
    
    public PaymentProcessorResultCodeDescription create(PaymentProcessorResultCodePK paymentProcessorResultCodePK, LanguagePK languagePK, String description, Long fromTime, Long thruTime)
            throws PersistenceDatabaseException, PersistenceNotNullException {
        return create(ThreadSession.currentSession(), paymentProcessorResultCodePK, languagePK, description, fromTime, thruTime);
    }
    
    public void create(Session session, Collection<PaymentProcessorResultCodeDescriptionValue> _values)
            throws PersistenceDatabaseException, PersistenceNotNullException {
        int _size = _values.size();
        
        if(_size > 0) {
            PreparedStatement _ps = session.prepareStatement(SQL_INSERT);
            List<PaymentProcessorResultCodeDescriptionValue> _cacheValues = new ArrayList<>(_size);
            
            try {
                for(PaymentProcessorResultCodeDescriptionValue _value : _values) {
                    _value.setEntityId(entityIdGenerator.getNextEntityId());
                    bindForCreate(_ps, _value);
                    
                    _ps.addBatch();
                    
                    _cacheValues.add(_value);
                }
                
                if(PersistenceDebugFlags.CheckEntityInsertRowCount) {
                    int[] _counts = _ps.executeBatch();
                    
                    for(int _countOffset = 0 ; _countOffset < _size ; _countOffset++) {
                        if(_counts[_countOffset] != 1 && _counts[_countOffset] != PreparedStatement.SUCCESS_NO_INFO) {
                            throw new PersistenceDatabaseUpdateException("batch insert failed, _counts[" + _countOffset + "] = " + _counts[_countOffset]);
                        }
                    }
                } else {
                     _ps.executeBatch();
                }
                
                _ps.clearBatch();
            } catch (SQLException se) {
                throw new PersistenceDatabaseException(se);
            }
            
            _cacheValues.forEach((_cacheValue) -> {
                PaymentProcessorResultCodeDescription _cacheEntity = new PaymentProcessorResultCodeDescription(_cacheValue, EntityPermission.READ_ONLY);
                
                session.putReadOnlyEntity(_cacheValue.getPrimaryKey(), _cacheEntity);
            });
        }
    }
    
    public void create(Collection<PaymentProcessorResultCodeDescriptionValue> _values)
            throws PersistenceDatabaseException, PersistenceNotNullException {
        create(ThreadSession.currentSession(), _values);
    }
    
    private boolean bindForStore(PreparedStatement _ps, PaymentProcessorResultCodeDescriptionValue _value)
            throws SQLException {
        boolean _hasBeenModified = _value.hasBeenModified();
        
        if(_hasBeenModified) {
            PaymentProcessorResultCodePK pprcrcd_pprcrc_paymentprocessorresultcodeid = _value.getPaymentProcessorResultCodePK();
            if(pprcrcd_pprcrc_paymentprocessorresultcodeid == null)
                _ps.setNull(1, Types.BIGINT);
            else
                _ps.setLong(1, pprcrcd_pprcrc_paymentprocessorresultcodeid.getEntityId());
            
            LanguagePK pprcrcd_lang_languageid = _value.getLanguagePK();
            if(pprcrcd_lang_languageid == null)
                _ps.setNull(2, Types.BIGINT);
            else
                _ps.setLong(2, pprcrcd_lang_languageid.getEntityId());
            
            String pprcrcd_description = _value.getDescription();
            if(pprcrcd_description == null)
                _ps.setNull(3, Types.VARCHAR);
            else
                _ps.setString(3, pprcrcd_description);
            
            Long pprcrcd_fromtime = _value.getFromTime();
            if(pprcrcd_fromtime == null)
                _ps.setNull(4, Types.BIGINT);
            else
                _ps.setLong(4, pprcrcd_fromtime);
            
            Long pprcrcd_thrutime = _value.getThruTime();
            if(pprcrcd_thrutime == null)
                _ps.setNull(5, Types.BIGINT);
            else
                _ps.setLong(5, pprcrcd_thrutime);
            
            _ps.setLong(6, _value.getPrimaryKey().getEntityId());
            
            _value.clearHasBeenModified();
        }
        
        return _hasBeenModified;
    }
    
    @Override
    public void store(Session session, PaymentProcessorResultCodeDescription entity)
            throws PersistenceDatabaseException {
        PreparedStatement _ps = session.prepareStatement(SQL_UPDATE);
        
        try {
            PaymentProcessorResultCodeDescriptionValue _value = entity.getPaymentProcessorResultCodeDescriptionValue();
            
            if(bindForStore(_ps, _value)) {
                if(PersistenceDebugFlags.CheckEntityUpdateRowCount) {
                    int _count = _ps.executeUpdate();
                    
                    if(_count != 1) {
                        throw new PersistenceDatabaseUpdateException("update failed, _count = " + _count);
                    }
                } else {
                     _ps.executeUpdate();
                }
                
                session.getValueCache().put(_value);
            }
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
    }
    
    @Override
    public void store(Session session, Collection<PaymentProcessorResultCodeDescription> entities)
            throws PersistenceDatabaseException {
        if(entities.size() > 0) {
            PreparedStatement _ps = session.prepareStatement(SQL_UPDATE);
            int _modifiedEntities = 0;
            
            try {
                for(PaymentProcessorResultCodeDescription entity : entities) {
                    if(bindForStore(_ps, entity.getPaymentProcessorResultCodeDescriptionValue())) {
                        _ps.addBatch();
                        _modifiedEntities++;
                    }
                }
                
                if(_modifiedEntities != 0) {
                    if(PersistenceDebugFlags.CheckEntityUpdateRowCount) {
                        int[] _counts = _ps.executeBatch();
                        
                        for(int _countOffset = 0 ; _countOffset < _modifiedEntities  ; _countOffset++) {
                            if(_counts[_countOffset] != 1 && _counts[_countOffset] != PreparedStatement.SUCCESS_NO_INFO) {
                                throw new PersistenceDatabaseUpdateException("batch update failed, _counts[" + _countOffset + "] = " + _counts[_countOffset]);
                            }
                        }
                    } else {
                         _ps.executeBatch();
                    }
                    
                    _ps.clearBatch();
                    
                    entities.forEach((entity) -> {
                        session.getValueCache().put(entity.getPaymentProcessorResultCodeDescriptionValue());
                    });
                }
            } catch (SQLException se) {
                throw new PersistenceDatabaseException(se);
            }
        }
    }
    
    @Override
    public void store(Collection<PaymentProcessorResultCodeDescription> entities)
            throws PersistenceDatabaseException {
        store(ThreadSession.currentSession(), entities);
    }
    
    @Override
    public void remove(Session session, PaymentProcessorResultCodeDescription entity)
            throws PersistenceDatabaseException {
        remove(session, entity.getPrimaryKey());
    }
    
    @Override
    public void remove(Session session, PaymentProcessorResultCodeDescriptionPK pk)
            throws PersistenceDatabaseException {
        PreparedStatement _ps = session.prepareStatement(SQL_DELETE);
        long _entityId = pk.getEntityId();
        
        try {
            _ps.setLong(1, _entityId);
            
            if(PersistenceDebugFlags.CheckEntityDeleteRowCount) {
                int _count = _ps.executeUpdate();
                
                if(_count != 1) {
                    throw new PersistenceDatabaseUpdateException("remove failed, _count = " + _count);
                }
            } else {
                 _ps.executeUpdate();
            }
            
            session.getValueCache().remove(pk);
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
        
        session.removed(pk, false);
    }
    
    @Override
    public void remove(Session session, Collection<PaymentProcessorResultCodeDescriptionPK> pks)
            throws PersistenceDatabaseException {
        if(pks.size() > 0) {
            PreparedStatement _ps = session.prepareStatement(SQL_DELETE);
            int _modifiedEntities = 0;
            
            try {
                for(PaymentProcessorResultCodeDescriptionPK pk : pks) {
                    long _entityId = pk.getEntityId();
                    
                    _ps.setLong(1, _entityId);
                    
                    _ps.addBatch();
                    _modifiedEntities++;
                }
                
                if(_modifiedEntities != 0) {
                    if(PersistenceDebugFlags.CheckEntityDeleteRowCount) {
                        int[] _counts = _ps.executeBatch();
                        
                        for(int _countOffset = 0 ; _countOffset < _modifiedEntities  ; _countOffset++) {
                            if(_counts[_countOffset] != 1 && _counts[_countOffset] != PreparedStatement.SUCCESS_NO_INFO) {
                                throw new PersistenceDatabaseUpdateException("batch remove failed, _counts[" + _countOffset + "] = " + _counts[_countOffset]);
                            }
                        }
                    } else {
                        _ps.executeBatch();
                    }
                    
                    _ps.clearBatch();
                    
                    pks.forEach((pk) -> {
                        session.getValueCache().remove(pk);
                    });
                }
            } catch (SQLException se) {
                throw new PersistenceDatabaseException(se);
            }
            
            pks.forEach((pk) -> {
                session.removed(pk, true);
            });
        }
    }
    
    @Override
    public void remove(Collection<PaymentProcessorResultCodeDescriptionPK> pks)
            throws PersistenceDatabaseException {
        remove(ThreadSession.currentSession(), pks);
    }
    
    @Override
    public boolean validPK(Session session, PaymentProcessorResultCodeDescriptionPK pk)
            throws PersistenceDatabaseException {
        boolean valid = false;
        PreparedStatement _ps = session.prepareStatement(SQL_VALID);
        ResultSet _rs = null;
        
        try {
            _ps.setLong(1, pk.getEntityId());
            
            _rs = _ps.executeQuery();
            if(_rs.next()) {
                long _count = _rs.getLong(1);
                if(_rs.wasNull())
                    _count = 0;
                
                if(_count == 1)
                    valid = true;
            }
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        } finally {
            if(_rs != null) {
                try {
                    _rs.close();
                } catch (SQLException se) {
                    // do nothing
                }
            }
        }
        
        return valid;
    }
    
}