NC6 vo操作管理类 nc.hr.frame.persistence.BaseDAOManager

package nc.hr.frame.persistence;

import java.sql.SQLException;
import java.util.Collection;
import java.util.List;

import nc.bs.dao.BaseDAO;
import nc.bs.dao.DAOException;
import nc.jdbc.framework.DataSourceCenter;
import nc.jdbc.framework.SQLParameter;
import nc.jdbc.framework.processor.BeanListProcessor;
import nc.jdbc.framework.processor.BeanProcessor;
import nc.jdbc.framework.util.DBConsts;
import nc.vo.hr.frame.persistence.BooleanProcessor;
import nc.vo.pub.SuperVO;

public class BaseDAOManager
{
    private BaseDAO baseDao;
    
    /**
     * 得到一个传入类型的查询结果集的对应的一个VO
     * @param <T>
     * @param sql
     * @param voClass
     * @return T
     * @throws DAOException
     */
    
    public <T> T executeQueryVO(String sql, Class<T> voClass) throws DAOException
    {
        return (T) getBaseDao().executeQuery(sql, new BeanProcessor(voClass));
    }
    
    /**
     * 得到一个传入类型的查询结果集的对应的一个VO
     * @param <T>
     * @param sql
     * @param parameter
     * @param voClass
     * @return T
     * @throws DAOException
     */
    
    public <T> T executeQueryVO(String sql, SQLParameter parameter, Class<T> voClass) throws DAOException
    {
        return (T) getBaseDao().executeQuery(sql, parameter, new BeanProcessor(voClass));
    }
    
    /**
     * 得到一个传入类型的查询结果集的数组
     * @param <T>
     * @param sql
     * @param voClass
     * @return T[]
     * @throws DAOException
     */
    
    public <T> T[] executeQueryVOs(String sql, Class<T> voClass) throws DAOException
    {
        List<T> list = (List<T>) getBaseDao().executeQuery(sql, new BeanListProcessor(voClass));
        if (list == null || list.size() == 0)
        {
            return (T[]) java.lang.reflect.Array.newInstance(voClass, 0);
        }
        
        return list.toArray((T[]) java.lang.reflect.Array.newInstance(voClass, list.size()));
        
    }
    
    /**
     * 得到一个传入类型的查询结果集的数组
     * @param <T>
     * @param sql
     * @param parameter
     * @param voClass
     * @return T[]
     * @throws DAOException
     */
    
    public <T> T[] executeQueryVOs(String sql, SQLParameter parameter, Class<T> voClass) throws DAOException
    {
        
        List<T> list = (List<T>) getBaseDao().executeQuery(sql, parameter, new BeanListProcessor(voClass));
        if (list == null || list.size() == 0)
        {
            return null;
        }
        return list.toArray((T[]) java.lang.reflect.Array.newInstance(voClass, list.size()));
    }
    
    /**
     * @return
     */
    public BaseDAO getBaseDao()
    {
        if (baseDao == null)
        {
            baseDao = new BaseDAO();
        }
        return baseDao;
    }
    
    /**
     * @param <T>
     * @param vos
     * @return
     * @throws DAOException
     */
    public <T extends SuperVO> T[] insertVOArrayReturnVOArray(T[] vos) throws DAOException
    {
        String[] pks = getBaseDao().insertVOArray(vos);
        for (int i = 0; i < vos.length; i++)
        {
            SuperVO vo = vos[i];
            vo.setPrimaryKey(pks[i]);
        }
        return vos;
    }
    
    /**
     * 判断是否是SQL数据库
     * @return
     * @throws SQLException
     */
    
    public boolean isSqlDbs() throws DAOException
    {
        return DBConsts.SQLSERVER == DataSourceCenter.getInstance().getDatabaseType();
    }
    
    /**
     * 通用的查询SQL是否存在查询结果
     * @param sql
     * @return boolean
     * @throws DAOException
     */
    public boolean isValueExist(String sql) throws DAOException
    {
        return (Boolean) getBaseDao().executeQuery(sql, new BooleanProcessor());
    }
    
    /**
     * 通用的查询SQL是否存在查询结果
     * @param sql
     * @param parameter
     * @return boolean
     * @throws DAOException
     */
    public boolean isValueExist(String sql, SQLParameter parameter) throws DAOException
    {
        return (Boolean) getBaseDao().executeQuery(sql, parameter, new BooleanProcessor());
    }
    
    /**
     * @param <T>
     * @param vo
     * @param isAnd
     * @return
     * @throws DAOException
     */
    
    public <T extends SuperVO> T[] retrieve(T vo, boolean isAnd) throws DAOException
    {
        Collection<T> c = getBaseDao().retrieve(vo, isAnd);
        if (c == null || c.size() == 0)
        {
            return null;
        }
        return c.toArray((T[]) java.lang.reflect.Array.newInstance(vo.getClass(), c.size()));
    }
    
    /**
     * @param <T>
     * @param voClass
     * @param condition
     * @return
     * @throws DAOException
     */
    
    public <T extends SuperVO> T[] retrieveByClause(Class<T> voClass, String condition) throws DAOException
    {
        
        Collection<T> c = getBaseDao().retrieveByClause(voClass, condition);
        if (c == null || c.size() == 0)
        {
            return null;
        }
        return c.toArray((T[]) java.lang.reflect.Array.newInstance(voClass, c.size()));
    }
    
    /**
     * @param <T>
     * @param voClass
     * @param pk
     * @return
     * @throws DAOException
     */
    
    public <T extends SuperVO> T retrieveByPK(Class<T> voClass, String pk) throws DAOException
    {
        return (T) getBaseDao().retrieveByPK(voClass, pk);
    }
    
    /**
     * @param <T>
     * @param vo
     * @param isAnd
     * @return
     * @throws DAOException
     */
    public <T extends SuperVO> T retrieveSingle(T vo) throws DAOException
    {
        T[] vos = retrieve(vo, true);
        vo = vos == null ? null : vos[0];
        return vo;
    }
}