// --------------------------------------------------------------------------------
// 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
// --------------------------------------------------------------------------------

/**
 * ShipmentStatusFactory.java
 */

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

import com.echothree.model.data.shipment.common.pk.ShipmentPK;

import com.echothree.model.data.shipment.server.entity.Shipment;

import com.echothree.model.data.shipment.common.ShipmentStatusConstants;
import com.echothree.model.data.shipment.common.pk.ShipmentStatusPK;
import com.echothree.model.data.shipment.server.value.ShipmentStatusValue;
import com.echothree.model.data.shipment.server.entity.ShipmentStatus;
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 ShipmentStatusFactory
        implements BaseFactory<ShipmentStatusPK, ShipmentStatus> {
    
    @Inject
    Session session;
    
    //private static final Logger log = LoggerFactory.getLogger(ShipmentStatusFactory.class);
    
    final private static String SQL_SELECT_READ_ONLY = "SELECT shpst_shipmentstatusid, shpst_shp_shipmentid, shpst_shipmentlinesequence FROM shipmentstatuses WHERE shpst_shipmentstatusid = ?";
    final private static String SQL_SELECT_READ_WRITE = "SELECT shpst_shipmentstatusid, shpst_shp_shipmentid, shpst_shipmentlinesequence FROM shipmentstatuses WHERE shpst_shipmentstatusid = ? FOR UPDATE";
    final private static String SQL_INSERT = "INSERT INTO shipmentstatuses (shpst_shipmentstatusid, shpst_shp_shipmentid, shpst_shipmentlinesequence) VALUES (?, ?, ?)";
    final private static String SQL_UPDATE = "UPDATE shipmentstatuses SET shpst_shp_shipmentid = ?, shpst_shipmentlinesequence = ? WHERE shpst_shipmentstatusid = ?";
    final private static String SQL_DELETE = "DELETE FROM shipmentstatuses WHERE shpst_shipmentstatusid = ?";
    final private static String SQL_VALID = "SELECT COUNT(*) FROM shipmentstatuses WHERE shpst_shipmentstatusid = ?";
    
    final private static String PK_COLUMN = "shpst_shipmentstatusid";
    final private static String ALL_COLUMNS = "shpst_shipmentstatusid, shpst_shp_shipmentid, shpst_shipmentlinesequence";
    final public static String TABLE_NAME = "shipmentstatuses";
    
    final public static String SHPST_SHIPMENTSTATUSID = "shpst_shipmentstatusid";
    final public static String SHPST_SHP_SHIPMENTID = "shpst_shp_shipmentid";
    final public static String SHPST_SHIPMENTLINESEQUENCE = "shpst_shipmentlinesequence";
    
    final private static EntityIdGenerator entityIdGenerator = new EntityIdGenerator(ShipmentStatusConstants.COMPONENT_VENDOR_NAME, ShipmentStatusConstants.ENTITY_TYPE_NAME);
    
    /** Creates a new instance of ShipmentStatusFactory */
    protected ShipmentStatusFactory() {
        super();
    }
    
    public static ShipmentStatusFactory getInstance() {
        return CDI.current().select(ShipmentStatusFactory.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 ShipmentStatusConstants.COMPONENT_VENDOR_NAME;
    }
    
    @Override
    public String getEntityTypeName() {
        return ShipmentStatusConstants.ENTITY_TYPE_NAME;
    }
    
    public PreparedStatement prepareStatement(String query) {
        return session.prepareStatement(ShipmentStatusFactory.class, query);
    }
    
    public ShipmentStatusPK getNextPK() {
        return new ShipmentStatusPK(entityIdGenerator.getNextEntityId());
    }
    
    public Set<ShipmentStatusPK> getPKsFromResultSetAsSet(ResultSet rs)
            throws PersistenceDatabaseException {
        Set<ShipmentStatusPK> _result = new HashSet<>();
        
        try {
            while(rs.next()) {
                _result.add(getPKFromResultSet(rs));
            }
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
        
        return _result;
    }
    
    public java.util.List<ShipmentStatusPK> getPKsFromResultSetAsList(ResultSet rs)
            throws PersistenceDatabaseException {
        java.util.List<ShipmentStatusPK> _result = new ArrayList<>();
        
        try {
            while(rs.next()) {
                _result.add(getPKFromResultSet(rs));
            }
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
        
        return _result;
    }
    
    public ShipmentStatusPK getPKFromResultSet(ResultSet rs)
            throws PersistenceDatabaseException {
        ShipmentStatusPK _result;
        
        try {
            long shpst_shipmentstatusid = rs.getLong(SHPST_SHIPMENTSTATUSID);
            Long _entityId = rs.wasNull() ? null : shpst_shipmentstatusid;
            
            _result = new ShipmentStatusPK(_entityId);
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
        
        return _result;
    }
    
    public java.util.List<ShipmentStatusValue> getValuesFromPKs(Collection<ShipmentStatusPK> pks)
            throws PersistenceDatabaseException {
        java.util.List<ShipmentStatusValue> _values = new ArrayList<>(pks.size());
        
        for(ShipmentStatusPK _pk: pks) {
            _values.add(getValueFromPK(_pk));
        }
        
        return _values;
    }
    
    public ShipmentStatusValue getValueFromPK(ShipmentStatusPK pk)
            throws PersistenceDatabaseException {
        ShipmentStatusValue _value;
        
        // See if we already have the entity in the session cache
        ShipmentStatus _entity = (ShipmentStatus)session.getEntity(pk);
        if(_entity == null)
            _value = getEntityFromPK(EntityPermission.READ_ONLY, pk).getShipmentStatusValue();
        else
            _value = _entity.getShipmentStatusValue();
        
        return _value;
    }
    
    public java.util.List<ShipmentStatusValue> getValuesFromResultSet(ResultSet rs)
            throws PersistenceDatabaseException {
        java.util.List<ShipmentStatusValue> _result = new ArrayList<>();
        
        try {
            while(rs.next()) {
                _result.add(getValueFromResultSet(rs));
            }
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
        
        return _result;
    }
    
    public ShipmentStatusValue getValueFromResultSet(ResultSet rs)
            throws PersistenceDatabaseException {
        ShipmentStatusValue _value;
        
        try {
            Long shpst_shipmentstatusid = rs.getLong(SHPST_SHIPMENTSTATUSID);
            ShipmentStatusPK _pk = new ShipmentStatusPK(shpst_shipmentstatusid);
            
            // See if we already have the entity in the session cache
            ShipmentStatus _entity = (ShipmentStatus)session.getEntity(_pk);
            
            if(_entity == null) {
                Long shpst_shp_shipmentid = rs.getLong(SHPST_SHP_SHIPMENTID);
                if(rs.wasNull())
                    shpst_shp_shipmentid = null;
                
                Integer shpst_shipmentlinesequence = rs.getInt(SHPST_SHIPMENTLINESEQUENCE);
                if(rs.wasNull())
                    shpst_shipmentlinesequence = null;
                
                _value = new ShipmentStatusValue(_pk, new ShipmentPK(shpst_shp_shipmentid), shpst_shipmentlinesequence);
            } else
                _value = _entity.getShipmentStatusValue();
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
        
        return _value;
    }
    
    public java.util.List<ShipmentStatus> getEntitiesFromPKs(EntityPermission entityPermission, Collection<ShipmentStatusPK> pks)
            throws PersistenceDatabaseException {
        java.util.List<ShipmentStatus> _entities = new ArrayList<>(pks.size());
        
        for(ShipmentStatusPK _pk: pks) {
            _entities.add(getEntityFromPK(entityPermission, _pk));
        }
        
        return _entities;
    }
    
    public ShipmentStatus getEntityFromValue(EntityPermission entityPermission, ShipmentStatusValue value) {
        return getEntityFromPK(entityPermission, value.getPrimaryKey());
    }
    
    public ShipmentStatus getEntityFromCache(ShipmentStatusPK pk) {
        ShipmentStatusValue _value = (ShipmentStatusValue)session.getValueCache().get(pk);
    
        return _value == null ? null : new ShipmentStatus(_value, EntityPermission.READ_ONLY);
    }
    
    public ShipmentStatus getEntityFromPK(EntityPermission entityPermission, ShipmentStatusPK pk)
            throws PersistenceDatabaseException {
        ShipmentStatus _entity;
        
        // See if we already have the entity in the session cache
        _entity = (ShipmentStatus)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<ShipmentStatusPK> getPKsFromQueryAsSet(PreparedStatement ps, final Object... params)
            throws PersistenceDatabaseException {
        Set<ShipmentStatusPK> _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<ShipmentStatusPK> getPKsFromQueryAsList(PreparedStatement ps, final Object... params)
            throws PersistenceDatabaseException {
        java.util.List<ShipmentStatusPK> _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 ShipmentStatusPK getPKFromQuery(PreparedStatement ps, final Object... params)
            throws PersistenceDatabaseException {
        ShipmentStatusPK _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<ShipmentStatus> getEntitiesFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap, final Object... params)
            throws PersistenceDatabaseException {
        PreparedStatement ps = session.prepareStatement(ShipmentStatusFactory.class, queryMap.get(entityPermission));
        
        return getEntitiesFromQuery(entityPermission, ps, params);
    }
    
    public java.util.List<ShipmentStatus> getEntitiesFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap)
            throws PersistenceDatabaseException {
        PreparedStatement ps = session.prepareStatement(ShipmentStatusFactory.class, queryMap.get(entityPermission));
        
        return getEntitiesFromQuery(entityPermission, ps);
    }
    
    public java.util.List<ShipmentStatus> getEntitiesFromQuery(EntityPermission entityPermission, PreparedStatement ps, final Object... params)
            throws PersistenceDatabaseException {
        java.util.List<ShipmentStatus> _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 ShipmentStatus getEntityFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap, final Object... params)
            throws PersistenceDatabaseException {
        PreparedStatement ps = session.prepareStatement(ShipmentStatusFactory.class, queryMap.get(entityPermission));
        
        return getEntityFromQuery(entityPermission, ps, params);
    }
    
    public ShipmentStatus getEntityFromQuery(EntityPermission entityPermission, Map<EntityPermission, String>queryMap)
            throws PersistenceDatabaseException {
        PreparedStatement ps = session.prepareStatement(ShipmentStatusFactory.class, queryMap.get(entityPermission));
        
        return getEntityFromQuery(entityPermission, ps);
    }
    
    public ShipmentStatus getEntityFromQuery(EntityPermission entityPermission, PreparedStatement ps, final Object... params)
            throws PersistenceDatabaseException {
        ShipmentStatus _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<ShipmentStatus> getEntitiesFromResultSet(EntityPermission entityPermission, ResultSet rs)
            throws PersistenceDatabaseException {
        java.util.List<ShipmentStatus> _result = new ArrayList<>();
        
        try {
            while(rs.next()) {
                _result.add(getEntityFromResultSet(entityPermission, rs));
            }
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
        
        return _result;
    }
    
    public ShipmentStatus getEntityFromResultSet(EntityPermission entityPermission, ResultSet rs)
            throws PersistenceDatabaseException {
        ShipmentStatus _entity;
        
        try {
            Long shpst_shipmentstatusid = rs.getLong(SHPST_SHIPMENTSTATUSID);
            ShipmentStatusPK _pk = new ShipmentStatusPK(shpst_shipmentstatusid);
            
            // See if we already have the entity in the session cache
            _entity = (ShipmentStatus)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) {
                Long shpst_shp_shipmentid = rs.getLong(SHPST_SHP_SHIPMENTID);
                if(rs.wasNull())
                    shpst_shp_shipmentid = null;
                
                Integer shpst_shipmentlinesequence = rs.getInt(SHPST_SHIPMENTLINESEQUENCE);
                if(rs.wasNull())
                    shpst_shipmentlinesequence = null;
                
                ShipmentStatusValue _value = new ShipmentStatusValue(_pk, shpst_shp_shipmentid == null? null: new ShipmentPK(shpst_shp_shipmentid), shpst_shipmentlinesequence);
                _entity = new ShipmentStatus(_value, entityPermission);
            }
            
            if(!foundInSessionCache) {
                if(entityPermission.equals(EntityPermission.READ_ONLY)) {
                    session.putReadOnlyEntity(_pk, _entity);
                    session.getValueCache().put(_entity.getShipmentStatusValue());
                } else {
                    session.putReadWriteEntity(_pk, _entity);
                }
            }
        } catch (SQLException se) {
            throw new PersistenceDatabaseException(se);
        }
        
        return _entity;
    }
    
    public ShipmentStatus create(Shipment shipment, Integer shipmentLineSequence)
            throws PersistenceDatabaseException, PersistenceNotNullException {
        return create(shipment == null ? null : shipment.getPrimaryKey(), shipmentLineSequence);
    }
    
    private void bindForCreate(PreparedStatement _ps, ShipmentStatusValue _value)
            throws SQLException {
        _ps.setLong(1, _value.getEntityId());
        
        ShipmentPK shpst_shp_shipmentid = _value.getShipmentPK();
        if(shpst_shp_shipmentid == null)
            _ps.setNull(2, Types.BIGINT);
        else
            _ps.setLong(2, shpst_shp_shipmentid.getEntityId());
            
        Integer shpst_shipmentlinesequence = _value.getShipmentLineSequence();
        if(shpst_shipmentlinesequence == null)
            _ps.setNull(3, Types.INTEGER);
        else
            _ps.setInt(3, shpst_shipmentlinesequence);
            
    }
    
    public ShipmentStatus create(ShipmentPK shipmentPK, Integer shipmentLineSequence)
            throws PersistenceDatabaseException, PersistenceNotNullException {
        ShipmentStatusPK _pk = getNextPK();
        ShipmentStatusValue _value = new ShipmentStatusValue(_pk, shipmentPK, shipmentLineSequence);
        
        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);
        }
        
        ShipmentStatus _entity = new ShipmentStatus(_value, EntityPermission.READ_ONLY);
        session.putReadOnlyEntity(_pk, _entity);
        
        return _entity;
    }
    
    public void create(Collection<ShipmentStatusValue> _values)
            throws PersistenceDatabaseException, PersistenceNotNullException {
        int _size = _values.size();
        
        if(_size > 0) {
            PreparedStatement _ps = session.prepareStatement(SQL_INSERT);
            List<ShipmentStatusValue> _cacheValues = new ArrayList<>(_size);
            
            try {
                for(ShipmentStatusValue _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) -> {
                ShipmentStatus _cacheEntity = new ShipmentStatus(_cacheValue, EntityPermission.READ_ONLY);
                
                session.putReadOnlyEntity(_cacheValue.getPrimaryKey(), _cacheEntity);
            });
        }
    }
    
    private boolean bindForStore(PreparedStatement _ps, ShipmentStatusValue _value)
            throws SQLException {
        boolean _hasBeenModified = _value.hasBeenModified();
        
        if(_hasBeenModified) {
            ShipmentPK shpst_shp_shipmentid = _value.getShipmentPK();
            if(shpst_shp_shipmentid == null)
                _ps.setNull(1, Types.BIGINT);
            else
                _ps.setLong(1, shpst_shp_shipmentid.getEntityId());
            
            Integer shpst_shipmentlinesequence = _value.getShipmentLineSequence();
            if(shpst_shipmentlinesequence == null)
                _ps.setNull(2, Types.INTEGER);
            else
                _ps.setInt(2, shpst_shipmentlinesequence);
            
            _ps.setLong(3, _value.getPrimaryKey().getEntityId());
            
            _value.clearHasBeenModified();
        }
        
        return _hasBeenModified;
    }
    
    @Override
    public void store(ShipmentStatus entity)
            throws PersistenceDatabaseException {
        PreparedStatement _ps = session.prepareStatement(SQL_UPDATE);
        
        try {
            ShipmentStatusValue _value = entity.getShipmentStatusValue();
            
            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<ShipmentStatus> entities)
            throws PersistenceDatabaseException {
        if(entities.size() > 0) {
            PreparedStatement _ps = session.prepareStatement(SQL_UPDATE);
            int _modifiedEntities = 0;
            
            try {
                for(ShipmentStatus entity : entities) {
                    if(bindForStore(_ps, entity.getShipmentStatusValue())) {
                        _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.getShipmentStatusValue());
                    });
                }
            } catch (SQLException se) {
                throw new PersistenceDatabaseException(se);
            }
        }
    }
    
    @Override
    public void remove(ShipmentStatus entity)
            throws PersistenceDatabaseException {
        remove(entity.getPrimaryKey());
    }
    
    @Override
    public void remove(ShipmentStatusPK 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<ShipmentStatusPK> pks)
            throws PersistenceDatabaseException {
        if(pks.size() > 0) {
            PreparedStatement _ps = session.prepareStatement(SQL_DELETE);
            int _modifiedEntities = 0;
            
            try {
                for(ShipmentStatusPK 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(ShipmentStatusPK 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;
    }
    
}