jdbcconnection.java

好像是一个SQL执行器的设计实现

package mytools.sqlclient;

import java.sql.*;
import mytools.util.*;
import java.sql.*;
import java.sql.Timestamp;
import com.borland.dx.dataset.*;
import java.io.*;
//import java.lang.reflect.*;
import java.math.*;

//Jdbc数据库连接
public class JdbcConnection
    implements IConnection
{
  public static final String MYTOOLS_HOST = Config.getParmValue("mytools.host"); //数据库服务器主机名
  public static final String MYTOOLS_DB_SID = Config.getParmValue("mytools.oracle.sid"); //数据库sid
  public static final String MYTOOLS_DB_USER = Config.getParmValue("mytools.oracle.user"); //数据库用户名
  public static final String MYTOOLS_DB_PWD = Config.getParmValue("mytools.oracle.pwd"); //数据库密码

  public static final long MAX_FETCH_ROW_NUM = 50000; //最大查询的记录行数
  Connection conn = null; //数据库连接

  public JdbcConnection(Connection po_conn)
  {
    conn = po_conn;
  }

  public JdbcConnection()
  {
    conn = createNewConnection();
  }

  /**
   功能:创建一个数据库连接
   @param 无
   @return 成功 数据库连接 失败 null
   */
  public Connection createNewConnection()
  {
    return connectDb(MYTOOLS_HOST, MYTOOLS_DB_SID, MYTOOLS_DB_USER, MYTOOLS_DB_PWD);
  }

  /**
   功能:连接数据库
   @param ps_host 主机名(或主机地址)
   @param ps_dbSid 数据库sid
   @param ps_user 数据库用户名
   @param ps_pwd  数据库用户密码
   @return  成功 连接对象  失败 null
   */
  private Connection connectDb(String ps_host, String ps_dbSid, String ps_user, String ps_pwd)
  {
    try
    {
      //加载数据库驱动程序
      DriverManager.registerDriver(new oracle.jdbc.driver.OracleDriver());

      //建立连接
      Connection lo_conn = DriverManager.getConnection(
          "jdbc:oracle:thin:@" + ps_host + ":1521:" + ps_dbSid, ps_user, ps_pwd);
      lo_conn.setAutoCommit(false);
      return lo_conn;
    }
    catch (Exception ex)
    {
      Util.logError("connectDb:error:" + ex);
      return null;
    }
  }

  /**
     功能:  错误处理
     @param pe_ex 例外
     @return 0
   */
  private int errProcess(Exception pe_ex)
  {
    if (pe_ex != null)
    {
      Util.logError(pe_ex.toString());
    }
    return 0;
  }

  /**
   功能:  取得sqltype类型对应的borland的dataset的字段类型
   @param pi_sqltype sql数据类型
   @param pi_scale 数据精度
   @return borland内部数据类型
   */
  private int getDataType(int pi_sqltype, int pi_scale)
  {
    switch (pi_sqltype)
    {
      case Types.CHAR:
      case Types.VARCHAR:
      case Types.LONGVARCHAR:
        return Variant.STRING;
        //case Types.DATE:
        //  return Variant.DATE;
      case Types.TIME:
        return Variant.TIME;
      case Types.DATE:
      case Types.TIMESTAMP:
        return Variant.TIMESTAMP;
      case Types.BIGINT:
      case Types.BIT:
      case Types.INTEGER:
      case Types.SMALLINT:
      case Types.TINYINT:

      case Types.NUMERIC:
      case Types.DECIMAL:
      case Types.REAL:
      case Types.DOUBLE:
      case Types.FLOAT:
        return Variant.BIGDECIMAL;
        /*
          if (pi_scale!=0)
            return Variant.DOUBLE;
          else
            return Variant.LONG;
         */
      default:
        return Variant.STRING;
    }
  }

  /**
    功能:取得当前记录指定int类型字段的值
    @param prs_data 数据集
    @param  pi_columnIndex  字段索引号(从1开始
    @return  成功 字段值 失败 ii_sqlcode不等0
   */
  private int getColInt(ResultSet prs_data, int pi_columnIndex)
  {

    if (pi_columnIndex < 1)
    {
      Util.logError("字段索引号:" + pi_columnIndex + "非法!应>=1");
      return 0;
    }
    try
    {
      return prs_data.getInt(pi_columnIndex);
    }
    catch (Exception ex)
    {
      return errProcess(ex);
    }
  }

  /**
    功能:取得当前记录指定int类型字段的值
    @param prs_data 数据集
    @param   ps_colname      字段名
    @return  成功 字段值  失败 ii_sqlcode不等0
   */
  private int getColInt(ResultSet prs_data, String ps_colname)
  {
    if (ps_colname.length() < 1)
    {
      Util.logError("字段名为空!");
      return 0;
    }
    try
    {
      return prs_data.getInt(ps_colname);
    }
    catch (Exception ex)
    {
      return errProcess(ex);
    }
  }

  /**
    功能:取得当前记录指定String类型字段的值
    @param prs_data 数据集
    @param  pi_columnIndex  字段索引号(从1开始)
    @return  成功 字段值 失败 ii_sqlcode不等0
   */
  private String getColString(ResultSet prs_data, int pi_columnIndex)
  {
    if (pi_columnIndex < 1)
    {
      Util.logError("字段索引号:" + pi_columnIndex + "非法!应>=1");
      return "";
    }
    try
    {
      return prs_data.getString(pi_columnIndex);
    }
    catch (Exception ex)
    {
      errProcess(ex);
      return "";
    }
  }

  /**
    功能:取得当前记录指定String类型字段的值
    @param prs_data 数据集
    @param  ps_colname      字段名
    @return  成功 字段值  失败 ii_sqlcode不等0
   */
  private String getColString(ResultSet prs_data, String ps_colname)
  {

    if (ps_colname.length() < 1)
    {
      Util.logError("字段名为空!");
      return "";
    }
    try
    {
      return prs_data.getString(ps_colname);
    }
    catch (Exception ex)
    {
      errProcess(ex);
      return "";
    }
  }

  /**
    功能:取得当前记录指定Date类型字段的值
    @param prs_data 数据集
    @param   pi_columnIndex  字段索引号(从1开始)
    @return  成功 字段值   失败 ii_sqlcode不等0
   */
  private java.sql.Date getColDate(ResultSet prs_data, int pi_columnIndex)
  {
    if (pi_columnIndex < 1)
    {
      Util.logError("字段索引号:" + pi_columnIndex + "非法!应>=1");
      return null;
    }
    try
    {
      return prs_data.getDate(pi_columnIndex);
    }
    catch (Exception ex)
    {
      errProcess(ex);
      return null;
    }
  }

  /**
    功能:取得当前记录指定Date类型字段的值
    @param prs_data 数据集
    @param ps_colname      字段名
    @return  成功 字段值   失败 ii_sqlcode不等0
   */
  private java.sql.Date getColDate(ResultSet prs_data, String ps_colname)
  {
    if (ps_colname.length() < 1)
    {
      Util.logError("字段名为空!");
      return null;
    }
    try
    {
      return prs_data.getDate(ps_colname);
    }
    catch (Exception ex)
    {
      errProcess(ex);
      return null;
    }
  }

  /**
    功能:取得当前记录指定Time类型字段的值
    @param prs_data 数据集
    @param  pi_columnIndex  字段索引号(从1开始)
    @return   成功 字段值    失败 ii_sqlcode不等0
   */
  private java.sql.Time getColTime(ResultSet prs_data, int pi_columnIndex)
  {
    if (pi_columnIndex < 1)
    {
      Util.logError("字段索引号:" + pi_columnIndex + "非法!应>=1");
      return null;
    }
    try
    {
      return prs_data.getTime(pi_columnIndex);
    }
    catch (Exception ex)
    {
      errProcess(ex);
      return null;
    }
  }

  /**
    功能:取得当前记录指定Time类型字段的值
    @param prs_data 数据集
    @param  ps_colname      字段名
    @return  成功 字段值  失败 ii_sqlcode不等0
   */
  private java.sql.Time getColTime(ResultSet prs_data, String ps_colname)
  {
    if (ps_colname.length() < 1)
    {
      Util.logError("字段名为空!");
      return null;
    }
    try
    {
      return prs_data.getTime(ps_colname);
    }
    catch (Exception ex)
    {
      errProcess(ex);
      return null;
    }
  }

  /**
    功能:取得当前记录指定Timestamp类型字段的值
    @param prs_data 数据集
    @param  pi_columnIndex  字段索引号(从1开始)
    @return  成功 字段值   失败 ii_sqlcode不等0
   */
  private java.sql.Timestamp getColTimestamp(ResultSet prs_data, int pi_columnIndex)
  {
    if (pi_columnIndex < 1)
    {
      Util.logError("字段索引号:" + pi_columnIndex + "非法!应>=1");
      return null;
    }
    try
    {
      return prs_data.getTimestamp(pi_columnIndex);
    }
    catch (Exception ex)
    {
      errProcess(ex);
      return null;
    }
  }

  /**
    功能:取得当前记录指定Timestamp类型字段的值
    @param prs_data 数据集
    @param   ps_colname      字段名
    @return  成功 字段值   失败 ii_sqlcode不等0
   */
  private java.sql.Timestamp getColTimestamp(ResultSet prs_data, String ps_colname)
  {
    if (ps_colname.length() < 1)
    {
      Util.logError("字段名为空!");
      return null;
    }
    try
    {
      return prs_data.getTimestamp(ps_colname);
    }
    catch (Exception ex)
    {
      errProcess(ex);
      return null;
    }
  }

  /**
    功能:取得当前记录指定double类型字段的值
    @param prs_data 数据集
    @param  pi_columnIndex  字段索引号(从1开始)
    @return 成功 字段值  失败 ii_sqlcode不等0
   */
  private double getColDouble(ResultSet prs_data, int pi_columnIndex)
  {
    if (pi_columnIndex < 1)
    {
      Util.logError("字段索引号:" + pi_columnIndex + "非法!应>=1");
      return 0;
    }
    try
    {
      return prs_data.getDouble(pi_columnIndex);
    }
    catch (Exception ex)
    {
      errProcess(ex);
      return 0;
    }
  }

  /**
    功能:取得当前记录指定double类型字段的值
    @param prs_data 数据集
    @param ps_colname      字段名
    @return  成功 字段值  失败 ii_sqlcode不等0
   */
  private double getColDouble(ResultSet prs_data, String ps_colname)
  {
    if (ps_colname.length() < 1)
    {
      Util.logError("字段名为空!");
      return 0;
    }
    try
    {
      return prs_data.getDouble(ps_colname);
    }
    catch (Exception ex)
    {
      errProcess(ex);
      return 0;
    }
  }

  /**
    功能:取得当前记录指定BigDecimal类型字段的值
    @param prs_data 数据集
    @param pi_columnIndex  字段索引号(从1开始)
    @return  成功 字段值   失败 ii_sqlcode不等0
   */
  private BigDecimal getColBigDecimal(ResultSet prs_data, int pi_columnIndex)
  {

    if (pi_columnIndex < 1)
    {
      Util.logError("字段索引号:" + pi_columnIndex + "非法!应>=1");
      return null;
    }
    try
    {
      return prs_data.getBigDecimal(pi_columnIndex);
    }
    catch (Exception ex)
    {
      errProcess(ex);
      return null;
    }
  }

  /**
    功能:取得当前记录指定BigDecimal类型字段的值
    @param prs_data 数据集
    @param  ps_colname      字段名
    @return 成功 字段值  失败 ii_sqlcode不等0
   */
  private BigDecimal getColBigDecimal(ResultSet prs_data, String ps_colname)
  {
    if (ps_colname.length() < 1)
    {
      Util.logError("字段名为空!");
      return null;
    }
    try
    {
      return prs_data.getBigDecimal(ps_colname);
    }
    catch (Exception ex)
    {
      errProcess(ex);
      return null;
    }
  }

  /**
    功能:取得当前记录指定InputStream类型字段的值
    @param prs_data 数据集
    @param  pi_columnIndex  字段索引号(从1开始)
    @return 成功 字段值  失败 ii_sqlcode不等0
   */
  private InputStream getColInputStream(ResultSet prs_data, int pi_columnIndex)
  {
    if (pi_columnIndex < 1)
    {
      Util.logError("字段索引号:" + pi_columnIndex + "非法!应>=1");
      return null;
    }
    try
    {
      return prs_data.getBinaryStream(pi_columnIndex);
    }
    catch (Exception ex)
    {
      errProcess(ex);
      return null;
    }
  }

  /**
   功能:  取得查询的数据集
   @param ps_sql sql语句
   @return 成功 查询的数据集 失败 null
   */
  private TableDataSet getTableDataSet2(String ps_sql)
  {
    TableDataSet lo_dataset = new TableDataSet();
    int li_colType, li_colScale;
    int li_colCount, i;
    ResultSet lrs_data = null; //数据集
    ResultSetMetaData lrmd_data = null;
    PreparedStatement lps_stmt = null; //sql语句类
    long ll_rownum = 0;
    try
    {
      lps_stmt = conn.prepareStatement(ps_sql);
      lrs_data = lps_stmt.executeQuery();
      if (lrs_data == null)
      {
        return null;
      }

      lrmd_data = lrs_data.getMetaData();
      //字段数
      li_colCount = lrmd_data.getColumnCount();

      lo_dataset.open();

      //定义数据集的字段信息
      Column[] columns = new Column[li_colCount];
      for (i = 0; i < li_colCount; i++)
      {
        li_colType = lrmd_data.getColumnType(i + 1);
        li_colScale = lrmd_data.getScale(i + 1);

        columns[i] = new Column(lrmd_data.getColumnName(i + 1),
                                lrmd_data.getColumnName(i + 1),
                                getDataType(li_colType, li_colScale));
      }

      //创建数据集字段信息
      int[] columnMap = ProviderHelp.initData(lo_dataset, columns, true, false, true);

      // Optionally the rowId could be set here.
      // The ResolverBean is the only consumer of this information.
      //设置记录的唯一标识字字段
      //dataSet.setAllRowIds(false);
      //Column rowid = dataSet.getColumn(ROWID_NAME);
      //rowid.setRowId(true);

      //设置该字段不显示
      //rowid.setHidden(true);

      //清空数据记录
      lo_dataset.empty();

      // 开始装入处理,形成装入数据缓冲区variants
      Variant[] variants = lo_dataset.startLoading(new LoadCancel()
      {
        public void cancelLoad()
        {}
      }

      , RowStatus.LOADED, false);

      ll_rownum = 0;
      while (lrs_data.next())
      {
        ll_rownum++;
        if (ll_rownum > MAX_FETCH_ROW_NUM)
        {
          Util.logError("查询记录数超过最大值:" + MAX_FETCH_ROW_NUM);
          return null;
        }

        for (int columnNo = 0; columnNo < columnMap.length; columnNo++)
        {
          // Get the ordinal of the column in the dataSet:
          int ordinal = columnMap[columnNo];

          //设置字段值到缓冲区中
          switch (variants[ordinal].getSetType())
          {
            case Variant.STRING:
              variants[ordinal].setString(getColString(lrs_data, columnNo + 1));

              break;
            case Variant.INT:
              variants[ordinal].setInt(getColInt(lrs_data, columnNo + 1));
              break;
            case Variant.BIGDECIMAL: