// --------------------------------------------------------------------------------
// Copyright 2002-2026 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
// --------------------------------------------------------------------------------

/**
 * CurrencyFactory.java
 */

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

import com.echothree.model.data.accounting.common.pk.SymbolPositionPK;

import com.echothree.model.data.accounting.server.entity.SymbolPosition;

import com.echothree.model.data.accounting.common.CurrencyConstants;
import com.echothree.model.data.accounting.common.pk.CurrencyPK;
import com.echothree.model.data.accounting.server.value.CurrencyValue;
import com.echothree.model.data.accounting.server.entity.Currency;
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 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 javax.inject.Inject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@ApplicationScoped
public class CurrencyFactory
        implements BaseFactory<CurrencyPK, Currency> {
    
    @Inject
    Session session;
    
    //private static final Logger log = LoggerFactory.getLogger(CurrencyFactory.class);
    
    final private static String SQL_SELECT_READ_ONLY = "SELECT cur_currencyid, cur_currencyisoname, cur_symbol, cur_sympos_symbolpositionid, cur_symbolonliststart, cur_symbolonlistmember, cur_symbolonsubtotal, cur_symbolontotal, cur_groupingseparator, cur_groupingsize, cur_fractionseparator, cur_defaultfractiondigits, cur_priceunitfractiondigits, cur_pricelinefractiondigits, cur_costunitfractiondigits, cur_costlinefractiondigits, cur_minussign, cur_isdefault, cur_sortorder FROM currencies WHERE cur_currencyid = ?";
    final private static String SQL_SELECT_READ_WRITE = "SELECT cur_currencyid, cur_currencyisoname, cur_symbol, cur_sympos_symbolpositionid, cur_symbolonliststart, cur_symbolonlistmember, cur_symbolonsubtotal, cur_symbolontotal, cur_groupingseparator, cur_groupingsize, cur_fractionseparator, cur_defaultfractiondigits, cur_priceunitfractiondigits, cur_pricelinefractiondigits, cur_costunitfractiondigits, cur_costlinefractiondigits, cur_minussign, cur_isdefault, cur_sortorder FROM currencies WHERE cur_currencyid = ? FOR UPDATE";
    final private static String SQL_INSERT = "INSERT INTO currencies (cur_currencyid, cur_currencyisoname, cur_symbol, cur_sympos_symbolpositionid, cur_symbolonliststart, cur_symbolonlistmember, cur_symbolonsubtotal, cur_symbolontotal, cur_groupingseparator, cur_groupingsize, cur_fractionseparator, cur_defaultfractiondigits, cur_priceunitfractiondigits, cur_pricelinefractiondigits, cur_costunitfractiondigits, cur_costlinefractiondigits, cur_minussign, cur_isdefault, cur_sortorder) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
    final private static String SQL_UPDATE = "UPDATE currencies SET cur_currencyisoname = ?, cur_symbol = ?, cur_sympos_symbolpositionid = ?, cur_symbolonliststart = ?, cur_symbolonlistmember = ?, cur_symbolonsubtotal = ?, cur_symbolontotal = ?, cur_groupingseparator = ?, cur_groupingsize = ?, cur_fractionseparator = ?, cur_defaultfractiondigits = ?, cur_priceunitfractiondigits = ?, cur_pricelinefractiondigits = ?, cur_costunitfractiondigits = ?, cur_costlinefractiondigits = ?, cur_minussign = ?, cur_isdefault = ?, cur_sortorder = ? WHERE cur_currencyid = ?";
    final private static String SQL_DELETE = "DELETE FROM currencies WHERE cur_currencyid = ?";
    final private static String SQL_VALID = "SELECT COUNT(*) FROM currencies WHERE cur_currencyid = ?";
    
    final private static String PK_COLUMN = "cur_currencyid";
    final private static String ALL_COLUMNS = "cur_currencyid, cur_currencyisoname, cur_symbol, cur_sympos_symbolpositionid, cur_symbolonliststart, cur_symbolonlistmember, cur_symbolonsubtotal, cur_symbolontotal, cur_groupingseparator, cur_groupingsize, cur_fractionseparator, cur_defaultfractiondigits, cur_priceunitfractiondigits, cur_pricelinefractiondigits, cur_costunitfractiondigits, cur_costlinefractiondigits, cur_minussign, cur_isdefault, cur_sortorder";
    final public static String TABLE_NAME = "currencies";
    
    final public static String CUR_CURRENCYID = "cur_currencyid";
    final public static String CUR_CURRENCYISONAME = "cur_currencyisoname";
    final public static String CUR_SYMBOL = "cur_symbol";
    final public static String CUR_SYMPOS_SYMBOLPOSITIONID = "cur_sympos_symbolpositionid";
    final public static String CUR_SYMBOLONLISTSTART = "cur_symbolonliststart";
    final public static String CUR_SYMBOLONLISTMEMBER = "cur_symbolonlistmember";
    final public static String CUR_SYMBOLONSUBTOTAL = "cur_symbolonsubtotal";
    final public static String CUR_SYMBOLONTOTAL = "cur_symbolontotal";
    final public static String CUR_GROUPINGSEPARATOR = "cur_groupingseparator";
    final public static String CUR_GROUPINGSIZE = "cur_groupingsize";
    final public static String CUR_FRACTIONSEPARATOR = "cur_fractionseparator";
    final public static String CUR_DEFAULTFRACTIONDIGITS = "cur_defaultfractiondigits";
    final public static String CUR_PRICEUNITFRACTIONDIGITS = "cur_priceunitfractiondigits";
    final public static String CUR_PRICELINEFRACTIONDIGITS = "cur_pricelinefractiondigits";
    final public static String CUR_COSTUNITFRACTIONDIGITS = "cur_costunitfractiondigits";
    final public static String CUR_COSTLINEFRACTIONDIGITS = "cur_costlinefractiondigits";
    final public static String CUR_MINUSSIGN = "cur_minussign";
    final public static String CUR_ISDEFAULT = "cur_isdefault";
    final public static String CUR_SORTORDER = "cur_sortorder";
    
    final private static EntityIdGenerator entityIdGenerator = new EntityIdGenerator(CurrencyConstants.COMPONENT_VENDOR_NAME, CurrencyConstants.ENTITY_TYPE_NAME);
    
    /** Creates a new instance of CurrencyFactory */
    protected CurrencyFactory() {
        super();
    }
    
    public static CurrencyFactory getInstance() {
        return CDI.current().select(CurrencyFactory.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 CurrencyConstants.COMPONENT_VENDOR_NAME;
    }
    
    @Override
    public String getEntityTypeName() {
        return CurrencyConstants.ENTITY_TYPE_NAME;
    }
    
    public PreparedStatement prepareStatement(String query) {
        return session.prepareStatement(CurrencyFactory.class, query);
    }
    
    public CurrencyPK getNextPK() {
        return new CurrencyPK(entityIdGenerator.getNextEntityId());
    }
    
    public Set<CurrencyPK> getPKsFromResultSetAsSet(ResultSet rs)
            throws PersistenceDatabaseException {
        Set<CurrencyPK> _result = new HashSet<>();
        
        try {
            while(rs.next()) {
                _result.add(getPKFromResultSet(rs));
            }
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
        
        return _result;
    }
    
    public java.util.List<CurrencyPK> getPKsFromResultSetAsList(ResultSet rs)
            throws PersistenceDatabaseException {
        java.util.List<CurrencyPK> _result = new ArrayList<>();
        
        try {
            while(rs.next()) {
                _result.add(getPKFromResultSet(rs));
            }
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
        
        return _result;
    }
    
    public CurrencyPK getPKFromResultSet(ResultSet rs)
            throws PersistenceDatabaseException {
        CurrencyPK _result;
        
        try {
            long cur_currencyid = rs.getLong(CUR_CURRENCYID);
            Long _entityId = rs.wasNull() ? null : cur_currencyid;
            
            _result = new CurrencyPK(_entityId);
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
        
        return _result;
    }
    
    public java.util.List<CurrencyValue> getValuesFromPKs(Collection<CurrencyPK> pks)
            throws PersistenceDatabaseException {
        java.util.List<CurrencyValue> _values = new ArrayList<>(pks.size());
        
        for(CurrencyPK _pk: pks) {
            _values.add(getValueFromPK(_pk));
        }
        
        return _values;
    }
    
    public CurrencyValue getValueFromPK(CurrencyPK pk)
            throws PersistenceDatabaseException {
        CurrencyValue _value;
        
        // See if we already have the entity in the session cache
        Currency _entity = (Currency)session.getEntity(pk);
        if(_entity == null)
            _value = getEntityFromPK(EntityPermission.READ_ONLY, pk).getCurrencyValue();
        else
            _value = _entity.getCurrencyValue();
        
        return _value;
    }
    
    public java.util.List<CurrencyValue> getValuesFromResultSet(ResultSet rs)
            throws PersistenceDatabaseException {
        java.util.List<CurrencyValue> _result = new ArrayList<>();
        
        try {
            while(rs.next()) {
                _result.add(getValueFromResultSet(rs));
            }
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
        
        return _result;
    }
    
    public CurrencyValue getValueFromResultSet(ResultSet rs)
            throws PersistenceDatabaseException {
        CurrencyValue _value;
        
        try {
            Long cur_currencyid = rs.getLong(CUR_CURRENCYID);
            CurrencyPK _pk = new CurrencyPK(cur_currencyid);
            
            // See if we already have the entity in the session cache
            Currency _entity = (Currency)session.getEntity(_pk);
            
            if(_entity == null) {
                String cur_currencyisoname = rs.getString(CUR_CURRENCYISONAME);
                if(rs.wasNull())
                    cur_currencyisoname = null;
                
                String cur_symbol = rs.getString(CUR_SYMBOL);
                if(rs.wasNull())
                    cur_symbol = null;
                
                Long cur_sympos_symbolpositionid = rs.getLong(CUR_SYMPOS_SYMBOLPOSITIONID);
                if(rs.wasNull())
                    cur_sympos_symbolpositionid = null;
                
                Boolean cur_symbolonliststart = rs.getInt(CUR_SYMBOLONLISTSTART) == 1;
                if(rs.wasNull())
                    cur_symbolonliststart = null;
                
                Boolean cur_symbolonlistmember = rs.getInt(CUR_SYMBOLONLISTMEMBER) == 1;
                if(rs.wasNull())
                    cur_symbolonlistmember = null;
                
                Boolean cur_symbolonsubtotal = rs.getInt(CUR_SYMBOLONSUBTOTAL) == 1;
                if(rs.wasNull())
                    cur_symbolonsubtotal = null;
                
                Boolean cur_symbolontotal = rs.getInt(CUR_SYMBOLONTOTAL) == 1;
                if(rs.wasNull())
                    cur_symbolontotal = null;
                
                String cur_groupingseparator = rs.getString(CUR_GROUPINGSEPARATOR);
                if(rs.wasNull())
                    cur_groupingseparator = null;
                
                Integer cur_groupingsize = rs.getInt(CUR_GROUPINGSIZE);
                if(rs.wasNull())
                    cur_groupingsize = null;
                
                String cur_fractionseparator = rs.getString(CUR_FRACTIONSEPARATOR);
                if(rs.wasNull())
                    cur_fractionseparator = null;
                
                Integer cur_defaultfractiondigits = rs.getInt(CUR_DEFAULTFRACTIONDIGITS);
                if(rs.wasNull())
                    cur_defaultfractiondigits = null;
                
                Integer cur_priceunitfractiondigits = rs.getInt(CUR_PRICEUNITFRACTIONDIGITS);
                if(rs.wasNull())
                    cur_priceunitfractiondigits = null;
                
                Integer cur_pricelinefractiondigits = rs.getInt(CUR_PRICELINEFRACTIONDIGITS);
                if(rs.wasNull())
                    cur_pricelinefractiondigits = null;
                
                Integer cur_costunitfractiondigits = rs.getInt(CUR_COSTUNITFRACTIONDIGITS);
                if(rs.wasNull())
                    cur_costunitfractiondigits = null;
                
                Integer cur_costlinefractiondigits = rs.getInt(CUR_COSTLINEFRACTIONDIGITS);
                if(rs.wasNull())
                    cur_costlinefractiondigits = null;
                
                String cur_minussign = rs.getString(CUR_MINUSSIGN);
                if(rs.wasNull())
                    cur_minussign = null;
                
                Boolean cur_isdefault = rs.getInt(CUR_ISDEFAULT) == 1;
                if(rs.wasNull())
                    cur_isdefault = null;
                
                Integer cur_sortorder = rs.getInt(CUR_SORTORDER);
                if(rs.wasNull())
                    cur_sortorder = null;
                
                _value = new CurrencyValue(_pk, cur_currencyisoname, cur_symbol, new SymbolPositionPK(cur_sympos_symbolpositionid), cur_symbolonliststart, cur_symbolonlistmember, cur_symbolonsubtotal, cur_symbolontotal, cur_groupingseparator, cur_groupingsize, cur_fractionseparator, cur_defaultfractiondigits, cur_priceunitfractiondigits, cur_pricelinefractiondigits, cur_costunitfractiondigits, cur_costlinefractiondigits, cur_minussign, cur_isdefault, cur_sortorder);
            } else
                _value = _entity.getCurrencyValue();
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
        
        return _value;
    }
    
    public java.util.List<Currency> getEntitiesFromPKs(EntityPermission entityPermission, Collection<CurrencyPK> pks)
            throws PersistenceDatabaseException {
        java.util.List<Currency> _entities = new ArrayList<>(pks.size());
        
        for(CurrencyPK _pk: pks) {
            _entities.add(getEntityFromPK(entityPermission, _pk));
        }
        
        return _entities;
    }
    
    public Currency getEntityFromValue(EntityPermission entityPermission, CurrencyValue value) {
        return getEntityFromPK(entityPermission, value.getPrimaryKey());
    }
    
    public Currency getEntityFromCache(CurrencyPK pk) {
        CurrencyValue _value = (CurrencyValue)session.getValueCache().get(pk);
    
        return _value == null ? null : new Currency(_value, EntityPermission.READ_ONLY);
    }
    
    public Currency getEntityFromPK(EntityPermission entityPermission, CurrencyPK pk)
            throws PersistenceDatabaseException {
        Currency _entity;
        
        // See if we already have the entity in the session cache
        _entity = (Currency)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(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(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<CurrencyPK> getPKsFromQueryAsSet(PreparedStatement ps, final Object... params)
            throws PersistenceDatabaseException {
        Set<CurrencyPK> _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<CurrencyPK> getPKsFromQueryAsList(PreparedStatement ps, final Object... params)
            throws PersistenceDatabaseException {
        java.util.List<CurrencyPK> _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 CurrencyPK getPKFromQuery(PreparedStatement ps, final Object... params)
            throws PersistenceDatabaseException {
        CurrencyPK _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<Currency> getEntitiesFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap, final Object... params)
            throws PersistenceDatabaseException {
        PreparedStatement ps = session.prepareStatement(CurrencyFactory.class, queryMap.get(entityPermission));
        
        return getEntitiesFromQuery(entityPermission, ps, params);
    }
    
    public java.util.List<Currency> getEntitiesFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap)
            throws PersistenceDatabaseException {
        PreparedStatement ps = session.prepareStatement(CurrencyFactory.class, queryMap.get(entityPermission));
        
        return getEntitiesFromQuery(entityPermission, ps);
    }
    
    public java.util.List<Currency> getEntitiesFromQuery(EntityPermission entityPermission, PreparedStatement ps, final Object... params)
            throws PersistenceDatabaseException {
        java.util.List<Currency> _entities;
        ResultSet _rs = null;
        
        try {
            if(params.length != 0) {
                Session.setQueryParams(ps, params);
            }
            
            _rs = ps.executeQuery();
            _entities = getEntitiesFromResultSet(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 Currency getEntityFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap, final Object... params)
            throws PersistenceDatabaseException {
        PreparedStatement ps = session.prepareStatement(CurrencyFactory.class, queryMap.get(entityPermission));
        
        return getEntityFromQuery(entityPermission, ps, params);
    }
    
    public Currency getEntityFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap)
            throws PersistenceDatabaseException {
        PreparedStatement ps = session.prepareStatement(CurrencyFactory.class, queryMap.get(entityPermission));
        
        return getEntityFromQuery(entityPermission, ps);
    }
    
    public Currency getEntityFromQuery(EntityPermission entityPermission, PreparedStatement ps, final Object... params)
            throws PersistenceDatabaseException {
        Currency _entity = null;
        ResultSet _rs = null;
        
        try {
            if(params.length != 0) {
                Session.setQueryParams(ps, params);
            }
            
            _rs = ps.executeQuery();
            if(_rs.next()) {
                _entity = getEntityFromResultSet(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<Currency> getEntitiesFromResultSet(EntityPermission entityPermission, ResultSet rs)
            throws PersistenceDatabaseException {
        java.util.List<Currency> _result = new ArrayList<>();
        
        try {
            while(rs.next()) {
                _result.add(getEntityFromResultSet(entityPermission, rs));
            }
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
        
        return _result;
    }
    
    public Currency getEntityFromResultSet(EntityPermission entityPermission, ResultSet rs)
            throws PersistenceDatabaseException {
        Currency _entity;
        
        try {
            Long cur_currencyid = rs.getLong(CUR_CURRENCYID);
            CurrencyPK _pk = new CurrencyPK(cur_currencyid);
            
            // See if we already have the entity in the session cache
            _entity = (Currency)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(_pk);
            }
            
            if(_entity == null) {
                String cur_currencyisoname = rs.getString(CUR_CURRENCYISONAME);
                if(rs.wasNull())
                    cur_currencyisoname = null;
                
                String cur_symbol = rs.getString(CUR_SYMBOL);
                if(rs.wasNull())
                    cur_symbol = null;
                
                Long cur_sympos_symbolpositionid = rs.getLong(CUR_SYMPOS_SYMBOLPOSITIONID);
                if(rs.wasNull())
                    cur_sympos_symbolpositionid = null;
                
                Boolean cur_symbolonliststart = rs.getInt(CUR_SYMBOLONLISTSTART) == 1;
                if(rs.wasNull())
                    cur_symbolonliststart = null;
                
                Boolean cur_symbolonlistmember = rs.getInt(CUR_SYMBOLONLISTMEMBER) == 1;
                if(rs.wasNull())
                    cur_symbolonlistmember = null;
                
                Boolean cur_symbolonsubtotal = rs.getInt(CUR_SYMBOLONSUBTOTAL) == 1;
                if(rs.wasNull())
                    cur_symbolonsubtotal = null;
                
                Boolean cur_symbolontotal = rs.getInt(CUR_SYMBOLONTOTAL) == 1;
                if(rs.wasNull())
                    cur_symbolontotal = null;
                
                String cur_groupingseparator = rs.getString(CUR_GROUPINGSEPARATOR);
                if(rs.wasNull())
                    cur_groupingseparator = null;
                
                Integer cur_groupingsize = rs.getInt(CUR_GROUPINGSIZE);
                if(rs.wasNull())
                    cur_groupingsize = null;
                
                String cur_fractionseparator = rs.getString(CUR_FRACTIONSEPARATOR);
                if(rs.wasNull())
                    cur_fractionseparator = null;
                
                Integer cur_defaultfractiondigits = rs.getInt(CUR_DEFAULTFRACTIONDIGITS);
                if(rs.wasNull())
                    cur_defaultfractiondigits = null;
                
                Integer cur_priceunitfractiondigits = rs.getInt(CUR_PRICEUNITFRACTIONDIGITS);
                if(rs.wasNull())
                    cur_priceunitfractiondigits = null;
                
                Integer cur_pricelinefractiondigits = rs.getInt(CUR_PRICELINEFRACTIONDIGITS);
                if(rs.wasNull())
                    cur_pricelinefractiondigits = null;
                
                Integer cur_costunitfractiondigits = rs.getInt(CUR_COSTUNITFRACTIONDIGITS);
                if(rs.wasNull())
                    cur_costunitfractiondigits = null;
                
                Integer cur_costlinefractiondigits = rs.getInt(CUR_COSTLINEFRACTIONDIGITS);
                if(rs.wasNull())
                    cur_costlinefractiondigits = null;
                
                String cur_minussign = rs.getString(CUR_MINUSSIGN);
                if(rs.wasNull())
                    cur_minussign = null;
                
                Boolean cur_isdefault = rs.getInt(CUR_ISDEFAULT) == 1;
                if(rs.wasNull())
                    cur_isdefault = null;
                
                Integer cur_sortorder = rs.getInt(CUR_SORTORDER);
                if(rs.wasNull())
                    cur_sortorder = null;
                
                CurrencyValue _value = new CurrencyValue(_pk, cur_currencyisoname, cur_symbol, cur_sympos_symbolpositionid == null? null: new SymbolPositionPK(cur_sympos_symbolpositionid), cur_symbolonliststart, cur_symbolonlistmember, cur_symbolonsubtotal, cur_symbolontotal, cur_groupingseparator, cur_groupingsize, cur_fractionseparator, cur_defaultfractiondigits, cur_priceunitfractiondigits, cur_pricelinefractiondigits, cur_costunitfractiondigits, cur_costlinefractiondigits, cur_minussign, cur_isdefault, cur_sortorder);
                _entity = new Currency(_value, entityPermission);
            }
            
            if(!foundInSessionCache) {
                if(entityPermission.equals(EntityPermission.READ_ONLY)) {
                    session.putReadOnlyEntity(_pk, _entity);
                    session.getValueCache().put(_entity.getCurrencyValue());
                } else {
                    session.putReadWriteEntity(_pk, _entity);
                }
            }
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
        
        return _entity;
    }
    
    public Currency create(String currencyIsoName, String symbol, SymbolPosition symbolPosition, Boolean symbolOnListStart, Boolean symbolOnListMember, Boolean symbolOnSubtotal, Boolean symbolOnTotal, String groupingSeparator, Integer groupingSize, String fractionSeparator, Integer defaultFractionDigits, Integer priceUnitFractionDigits, Integer priceLineFractionDigits, Integer costUnitFractionDigits, Integer costLineFractionDigits, String minusSign, Boolean isDefault, Integer sortOrder)
            throws PersistenceDatabaseException, PersistenceNotNullException {
        return create(currencyIsoName, symbol, symbolPosition == null ? null : symbolPosition.getPrimaryKey(), symbolOnListStart, symbolOnListMember, symbolOnSubtotal, symbolOnTotal, groupingSeparator, groupingSize, fractionSeparator, defaultFractionDigits, priceUnitFractionDigits, priceLineFractionDigits, costUnitFractionDigits, costLineFractionDigits, minusSign, isDefault, sortOrder);
    }
    
    private void bindForCreate(PreparedStatement _ps, CurrencyValue _value)
            throws SQLException {
        _ps.setLong(1, _value.getEntityId());
        
        String cur_currencyisoname = _value.getCurrencyIsoName();
        if(cur_currencyisoname == null)
            _ps.setNull(2, Types.VARCHAR);
        else
            _ps.setString(2, cur_currencyisoname);
            
        String cur_symbol = _value.getSymbol();
        if(cur_symbol == null)
            _ps.setNull(3, Types.VARCHAR);
        else
            _ps.setString(3, cur_symbol);
            
        SymbolPositionPK cur_sympos_symbolpositionid = _value.getSymbolPositionPK();
        if(cur_sympos_symbolpositionid == null)
            _ps.setNull(4, Types.BIGINT);
        else
            _ps.setLong(4, cur_sympos_symbolpositionid.getEntityId());
            
        Boolean cur_symbolonliststart = _value.getSymbolOnListStart();
        if(cur_symbolonliststart == null)
            _ps.setNull(5, Types.BIT);
        else
            _ps.setInt(5, cur_symbolonliststart? 1: 0);
            
        Boolean cur_symbolonlistmember = _value.getSymbolOnListMember();
        if(cur_symbolonlistmember == null)
            _ps.setNull(6, Types.BIT);
        else
            _ps.setInt(6, cur_symbolonlistmember? 1: 0);
            
        Boolean cur_symbolonsubtotal = _value.getSymbolOnSubtotal();
        if(cur_symbolonsubtotal == null)
            _ps.setNull(7, Types.BIT);
        else
            _ps.setInt(7, cur_symbolonsubtotal? 1: 0);
            
        Boolean cur_symbolontotal = _value.getSymbolOnTotal();
        if(cur_symbolontotal == null)
            _ps.setNull(8, Types.BIT);
        else
            _ps.setInt(8, cur_symbolontotal? 1: 0);
            
        String cur_groupingseparator = _value.getGroupingSeparator();
        if(cur_groupingseparator == null)
            _ps.setNull(9, Types.VARCHAR);
        else
            _ps.setString(9, cur_groupingseparator);
            
        Integer cur_groupingsize = _value.getGroupingSize();
        if(cur_groupingsize == null)
            _ps.setNull(10, Types.INTEGER);
        else
            _ps.setInt(10, cur_groupingsize);
            
        String cur_fractionseparator = _value.getFractionSeparator();
        if(cur_fractionseparator == null)
            _ps.setNull(11, Types.VARCHAR);
        else
            _ps.setString(11, cur_fractionseparator);
            
        Integer cur_defaultfractiondigits = _value.getDefaultFractionDigits();
        if(cur_defaultfractiondigits == null)
            _ps.setNull(12, Types.INTEGER);
        else
            _ps.setInt(12, cur_defaultfractiondigits);
            
        Integer cur_priceunitfractiondigits = _value.getPriceUnitFractionDigits();
        if(cur_priceunitfractiondigits == null)
            _ps.setNull(13, Types.INTEGER);
        else
            _ps.setInt(13, cur_priceunitfractiondigits);
            
        Integer cur_pricelinefractiondigits = _value.getPriceLineFractionDigits();
        if(cur_pricelinefractiondigits == null)
            _ps.setNull(14, Types.INTEGER);
        else
            _ps.setInt(14, cur_pricelinefractiondigits);
            
        Integer cur_costunitfractiondigits = _value.getCostUnitFractionDigits();
        if(cur_costunitfractiondigits == null)
            _ps.setNull(15, Types.INTEGER);
        else
            _ps.setInt(15, cur_costunitfractiondigits);
            
        Integer cur_costlinefractiondigits = _value.getCostLineFractionDigits();
        if(cur_costlinefractiondigits == null)
            _ps.setNull(16, Types.INTEGER);
        else
            _ps.setInt(16, cur_costlinefractiondigits);
            
        String cur_minussign = _value.getMinusSign();
        if(cur_minussign == null)
            _ps.setNull(17, Types.VARCHAR);
        else
            _ps.setString(17, cur_minussign);
            
        Boolean cur_isdefault = _value.getIsDefault();
        if(cur_isdefault == null)
            _ps.setNull(18, Types.BIT);
        else
            _ps.setInt(18, cur_isdefault? 1: 0);
            
        Integer cur_sortorder = _value.getSortOrder();
        if(cur_sortorder == null)
            _ps.setNull(19, Types.INTEGER);
        else
            _ps.setInt(19, cur_sortorder);
            
    }
    
    public Currency create(String currencyIsoName, String symbol, SymbolPositionPK symbolPositionPK, Boolean symbolOnListStart, Boolean symbolOnListMember, Boolean symbolOnSubtotal, Boolean symbolOnTotal, String groupingSeparator, Integer groupingSize, String fractionSeparator, Integer defaultFractionDigits, Integer priceUnitFractionDigits, Integer priceLineFractionDigits, Integer costUnitFractionDigits, Integer costLineFractionDigits, String minusSign, Boolean isDefault, Integer sortOrder)
            throws PersistenceDatabaseException, PersistenceNotNullException {
        CurrencyPK _pk = getNextPK();
        CurrencyValue _value = new CurrencyValue(_pk, currencyIsoName, symbol, symbolPositionPK, symbolOnListStart, symbolOnListMember, symbolOnSubtotal, symbolOnTotal, groupingSeparator, groupingSize, fractionSeparator, defaultFractionDigits, priceUnitFractionDigits, priceLineFractionDigits, costUnitFractionDigits, costLineFractionDigits, minusSign, isDefault, sortOrder);
        
        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);
        }
        
        Currency _entity = new Currency(_value, EntityPermission.READ_ONLY);
        session.putReadOnlyEntity(_pk, _entity);
        
        return _entity;
    }
    
    public void create(Collection<CurrencyValue> _values)
            throws PersistenceDatabaseException, PersistenceNotNullException {
        int _size = _values.size();
        
        if(_size > 0) {
            PreparedStatement _ps = session.prepareStatement(SQL_INSERT);
            List<CurrencyValue> _cacheValues = new ArrayList<>(_size);
            
            try {
                for(CurrencyValue _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) -> {
                Currency _cacheEntity = new Currency(_cacheValue, EntityPermission.READ_ONLY);
                
                session.putReadOnlyEntity(_cacheValue.getPrimaryKey(), _cacheEntity);
            });
        }
    }
    
    private boolean bindForStore(PreparedStatement _ps, CurrencyValue _value)
            throws SQLException {
        boolean _hasBeenModified = _value.hasBeenModified();
        
        if(_hasBeenModified) {
            String cur_currencyisoname = _value.getCurrencyIsoName();
            if(cur_currencyisoname == null)
                _ps.setNull(1, Types.VARCHAR);
            else
                _ps.setString(1, cur_currencyisoname);
            
            String cur_symbol = _value.getSymbol();
            if(cur_symbol == null)
                _ps.setNull(2, Types.VARCHAR);
            else
                _ps.setString(2, cur_symbol);
            
            SymbolPositionPK cur_sympos_symbolpositionid = _value.getSymbolPositionPK();
            if(cur_sympos_symbolpositionid == null)
                _ps.setNull(3, Types.BIGINT);
            else
                _ps.setLong(3, cur_sympos_symbolpositionid.getEntityId());
            
            Boolean cur_symbolonliststart = _value.getSymbolOnListStart();
            if(cur_symbolonliststart == null)
                _ps.setNull(4, Types.BIT);
            else
                _ps.setInt(4, cur_symbolonliststart? 1: 0);
            
            Boolean cur_symbolonlistmember = _value.getSymbolOnListMember();
            if(cur_symbolonlistmember == null)
                _ps.setNull(5, Types.BIT);
            else
                _ps.setInt(5, cur_symbolonlistmember? 1: 0);
            
            Boolean cur_symbolonsubtotal = _value.getSymbolOnSubtotal();
            if(cur_symbolonsubtotal == null)
                _ps.setNull(6, Types.BIT);
            else
                _ps.setInt(6, cur_symbolonsubtotal? 1: 0);
            
            Boolean cur_symbolontotal = _value.getSymbolOnTotal();
            if(cur_symbolontotal == null)
                _ps.setNull(7, Types.BIT);
            else
                _ps.setInt(7, cur_symbolontotal? 1: 0);
            
            String cur_groupingseparator = _value.getGroupingSeparator();
            if(cur_groupingseparator == null)
                _ps.setNull(8, Types.VARCHAR);
            else
                _ps.setString(8, cur_groupingseparator);
            
            Integer cur_groupingsize = _value.getGroupingSize();
            if(cur_groupingsize == null)
                _ps.setNull(9, Types.INTEGER);
            else
                _ps.setInt(9, cur_groupingsize);
            
            String cur_fractionseparator = _value.getFractionSeparator();
            if(cur_fractionseparator == null)
                _ps.setNull(10, Types.VARCHAR);
            else
                _ps.setString(10, cur_fractionseparator);
            
            Integer cur_defaultfractiondigits = _value.getDefaultFractionDigits();
            if(cur_defaultfractiondigits == null)
                _ps.setNull(11, Types.INTEGER);
            else
                _ps.setInt(11, cur_defaultfractiondigits);
            
            Integer cur_priceunitfractiondigits = _value.getPriceUnitFractionDigits();
            if(cur_priceunitfractiondigits == null)
                _ps.setNull(12, Types.INTEGER);
            else
                _ps.setInt(12, cur_priceunitfractiondigits);
            
            Integer cur_pricelinefractiondigits = _value.getPriceLineFractionDigits();
            if(cur_pricelinefractiondigits == null)
                _ps.setNull(13, Types.INTEGER);
            else
                _ps.setInt(13, cur_pricelinefractiondigits);
            
            Integer cur_costunitfractiondigits = _value.getCostUnitFractionDigits();
            if(cur_costunitfractiondigits == null)
                _ps.setNull(14, Types.INTEGER);
            else
                _ps.setInt(14, cur_costunitfractiondigits);
            
            Integer cur_costlinefractiondigits = _value.getCostLineFractionDigits();
            if(cur_costlinefractiondigits == null)
                _ps.setNull(15, Types.INTEGER);
            else
                _ps.setInt(15, cur_costlinefractiondigits);
            
            String cur_minussign = _value.getMinusSign();
            if(cur_minussign == null)
                _ps.setNull(16, Types.VARCHAR);
            else
                _ps.setString(16, cur_minussign);
            
            Boolean cur_isdefault = _value.getIsDefault();
            if(cur_isdefault == null)
                _ps.setNull(17, Types.BIT);
            else
                _ps.setInt(17, cur_isdefault? 1: 0);
            
            Integer cur_sortorder = _value.getSortOrder();
            if(cur_sortorder == null)
                _ps.setNull(18, Types.INTEGER);
            else
                _ps.setInt(18, cur_sortorder);
            
            _ps.setLong(19, _value.getPrimaryKey().getEntityId());
            
            _value.clearHasBeenModified();
        }
        
        return _hasBeenModified;
    }
    
    @Override
    public void store(Currency entity)
            throws PersistenceDatabaseException {
        PreparedStatement _ps = session.prepareStatement(SQL_UPDATE);
        
        try {
            CurrencyValue _value = entity.getCurrencyValue();
            
            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(Collection<Currency> entities)
            throws PersistenceDatabaseException {
        if(entities.size() > 0) {
            PreparedStatement _ps = session.prepareStatement(SQL_UPDATE);
            int _modifiedEntities = 0;
            
            try {
                for(Currency entity : entities) {
                    if(bindForStore(_ps, entity.getCurrencyValue())) {
                        _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.getCurrencyValue());
                    });
                }
            } catch (SQLException se) {
                throw new PersistenceDatabaseException(se);
            }
        }
    }
    
    @Override
    public void remove(Currency entity)
            throws PersistenceDatabaseException {
        remove(entity.getPrimaryKey());
    }
    
    @Override
    public void remove(CurrencyPK 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(Collection<CurrencyPK> pks)
            throws PersistenceDatabaseException {
        if(pks.size() > 0) {
            PreparedStatement _ps = session.prepareStatement(SQL_DELETE);
            int _modifiedEntities = 0;
            
            try {
                for(CurrencyPK 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 boolean validPK(CurrencyPK 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;
    }
    
}