blogjava's web log

blogjava's web log
...

DButil

package  com.common.website;

 import  java.sql.Connection;
 import  java.sql.DriverManager;
 import  java.sql.ResultSet;
 import  java.sql.SQLException;
 import  java.sql.Statement;
 import  java.util.ArrayList;
 import  java.util.Collection;
 import  java.util.Iterator;
 import  java.util.LinkedList;

 /**
 * 这是一个提供了操作数据库方法的类
 * 例：
 * String sql="select * from table";
 * ArrayList list=DBSql.query(sql);
 * 调用query()方法传入sql语句来执行数据库的操作返回的是ArrayList.ArrayList中的一个元素就是数据库中的一行
 * 这个只是此类里面的简单的方法应用还有一些方法是带有事务处理的
 * scholiast :xudelin
  */
public   final   class  DBSql  {
     private   static   final  String errPrefix  =  DBSql. class .getName();
     public   static  Connection getCon()
     {        
        Connection con = null ;
        String url  =   " jdbc:oracle:thin:@61.152.169.215:1522:DMSYS " ;
         try  
         {                 
            Class.forName( " oracle.jdbc.driver.OracleDriver " );            
        }
         catch  (ClassNotFoundException e) 
         { 
            System.out.println( " class not found: "   +  e.getMessage());    
        }
         try  
         {
            con  =  DriverManager.getConnection(url,  " dm " ,  " roadway_com " );            
        }
         catch  (SQLException a) 
         {
            System.out.println( " sql exception: "   +  a.getMessage());
        }
         return  con;
    }

     private  DBSql()  {
    }

     /**
     * <p>查询数据库</p>
     *
     *  @param  sql 查询语句
     *  @return  ArrayList类型的行集查询结果，其中每个行集也是ArrayList类型
     *  @throws  SQLException SQL异常
      */
     public   static  ArrayList query( final  String sql)  throws  SQLException  {
         return  myQuery(sql,  null ,  0 );
    }

     /**
     * <p>查询数据库</p>
     *
     *  @param  sql        查询语句
     *  @param  beginIndex 起始位置，从1开始，不用担心越界
     *  @param  num        个数，不用担心越界
     *  @return  ArrayList类型的行集查询结果，其中每个行集也是ArrayList类型
     *  @throws  SQLException SQL异常
      */
     public   static  ArrayList query( final  String sql,  final   int  beginIndex,  final   int  num)  throws  SQLException  {
         return  myQuery(sql,  null , beginIndex, num,  0 );
    }

     /**
     * <p>查询数据库</p>分页查询时使用
     *  @param  sql        查询语句
     *  @param  curPage     当前页数
     *  @param  num      每页显示的数量
     *  @return
     *  @throws  SQLException
      */
     public   static  ArrayList queryPage( final  String sql,  final   int  curPage,  final   int  num)  throws  SQLException  {
         int  beginIndex  =  num  *  (curPage  -   1 )  +   1 ;
         return  myQuery(sql,  null , beginIndex, num,  0 );
    }

     /**
     * <p>查询数据库</p>
     *
     *  @param  sql 查询语句
     *  @param  con 数据库连接
     *  @return  ArrayList类型的行集查询结果，其中每个行集也是ArrayList类型
     *  @throws  SQLException SQL异常
      */
     public   static  ArrayList query( final  String sql,  final  Connection con)  throws  SQLException  {
         return  myQuery(sql, con,  0 );
    }

     /**
     * <p>查询数据库</p>
     *
     *  @param  sql        查询语句
     *  @param  con        数据库连接
     *  @param  beginIndex 起始位置，从1开始，不用担心越界
     *  @param  num        个数，不用担心越界
     *  @return  ArrayList类型的行集查询结果，其中每个行集也是ArrayList类型
     *  @throws  SQLException SQL异常
      */
     public   static  ArrayList query( final  String sql,  final  Connection con,  final   int  beginIndex,  final   int  num)  throws  SQLException  {
         return  myQuery(sql, con, beginIndex, num,  0 );
    }

     /**
     * <p>查询数据库</p>
     *
     *  @param  sql 查询语句
     *  @return  ArrayList类型的查询结果，按查询结果顺序依次放入一个List中。
     *  @throws  SQLException SQL异常
      */
     public   static  ArrayList queryOneList( final  String sql)  throws  SQLException  {
         return  myQuery(sql,  null ,  1 );
    }

     /**
     * <p>查询数据库</p>
     *
     *  @param  sql        查询语句
     *  @param  beginIndex 起始位置，从1开始，不用担心越界
     *  @param  num        个数，不用担心越界
     *  @return  ArrayList类型的查询结果，按查询结果顺序依次放入一个List中。
     *  @throws  SQLException SQL异常
      */
     public   static  ArrayList queryOneList( final  String sql,  final   int  beginIndex,  final   int  num)  throws  SQLException  {
         return  myQuery(sql,  null , beginIndex, num,  1 );
    }

     /**
     * <p>查询数据库</p>
     *
     *  @param  sql 查询语句
     *  @param  con 数据库连接
     *  @return  ArrayList类型的查询结果，按查询结果顺序依次放入一个List中。
     *  @throws  SQLException SQL异常
      */
     public   static  ArrayList queryOneList( final  String sql,  final  Connection con)  throws  SQLException  {
         return  myQuery(sql, con,  1 );
    }

     /**
     * <p>查询数据库</p>
     *
     *  @param  sql        查询语句
     *  @param  con        数据库连接
     *  @param  beginIndex 起始位置，从1开始，不用担心越界
     *  @param  num        个数，不用担心越界
     *  @return  ArrayList类型的查询结果，按查询结果顺序依次放入一个List中。
     *  @throws  SQLException SQL异常
      */
     public   static  ArrayList queryOneList( final  String sql,  final  Connection con,  final   int  beginIndex,  final   int  num)  throws  SQLException  {
         return  myQuery(sql, con, beginIndex, num,  1 );
    }

     /**
     * <p>查询数据库</p>
     *
     *  @param  sql 查询语句
     *  @return  ArrayList类型的查询结果，只取第一行的记录。
     *  @throws  SQLException SQL异常
      */
     public   static  ArrayList queryFirstRow( final  String sql)  throws  SQLException  {
         return  myQuery(sql,  null ,  2 );
    }

     /**
     * <p>查询数据库</p>
     *
     *  @param  sql 查询语句
     *  @param  con 数据库连接
     *  @return  ArrayList类型的查询结果，只取第一行的记录。
     *  @throws  SQLException SQL异常
      */
     public   static  ArrayList queryFirstRow( final  String sql,  final  Connection con)  throws  SQLException  {
         return  myQuery(sql, con,  2 );
    }

     /**
     * <p>查询数据库</p>
     *
     *  @param  sql  查询语句
     *  @param  con  数据库的连接
     *  @param  type 0表示两层结构，1表示一层结构，2表示只取第一行
     *  @return  ArrayList类型的行集查询结果，其中每个行集也是ArrayList类型
     *  @throws  SQLException SQL异常
      */
     private   static  ArrayList myQuery( final  String sql,  final  Connection con,  final   int  type)  throws  SQLException  {
         return  myQuery(sql, con,  - 1 ,  - 1 , type);
    }

     /**
     * <p>查询数据库</p>
     *
     *  @param  sql        查询语句
     *  @param  conn       数据库的连接
     *  @param  type       0表示两层结构，1表示一层结构，2表示只取第一行
     *  @param  beginIndex 起始位置，从1开始，不用担心越界
     *  @param  num        个数，不用担心越界
     *  @return  ArrayList类型的行集查询结果，其中每个行集也是ArrayList类型
     *  @throws  SQLException SQL异常
      */
     private   static  ArrayList myQuery( final  String sql,  final  Connection conn,  final   int  beginIndex,  final   int  num,  final   int  type)  throws  SQLException  {
         final  String exsql  =  sql.trim();
         int  begin  =  beginIndex;
         int  count  =  num;
         boolean  needPosition  =   false ;
         if  (begin  !=   - 1   ||  count  !=   - 1 )  {
            needPosition  =   true ;
        }
        ArrayList list  =   new  ArrayList();
        Connection con  =   null ;
        Statement stmt  =   null ;
        ResultSet rs  =   null ;        
         try   {
            con  =  conn  ==   null   ?  DBSql.getCon() : conn;
             if  (needPosition)  {
                stmt  =  con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
            }   else   {
                stmt  =  con.createStatement();
            }
            rs  =  stmt.executeQuery(exsql);
             // aban add start
   //         System.out.print(exsql+";\n");
           // aban add end
           if  (rs  ==   null )  {
                 return  list;
            }
             int  size  =   - 1 ;
             if  (needPosition)  {
                 if  ( ! rs.next())  {
                     return  list;
                }
                rs.last();
                size  =  rs.getRow();
                rs.first();
                 if  (begin  <   1 )  {
                    begin  =   1 ;
                }
                 if  (count  ==   - 1   ||  begin  +  count  >  size  +   1 )  {
                    count  =  size  -  begin  +   1 ;
                }
            }
             if  (type  ==   0 )  {
                list  =  needPosition  ?  resToList(rs, begin, count, size) : resToList(rs);
            }   else   if  (type  ==   1 )  {
                list  =  needPosition  ?  resToOneList(rs, begin, count, size) : resToOneList(rs);
            }   else   if  (type  ==   2 )  {
                list  =  resToFirstList(rs);
            }
             return  list;
        }   catch  (SQLException ex)  {
            System.out.println(errPrefix  +   "  : myQuery: "   +  ex  +   " .\r\nmyQuery:sql = \r\n "   +  exsql);
             throw  ex;
        }   finally   {
             if  (conn  ==   null )  {
                freeResource(rs, stmt, con);
            }   else   {
                freeResource(rs, stmt);
            }
        }
    }

     /**
     * <p>执行插入、更新和删除操作的，某一条SQL语句，支持事务的回滚</p>
     *
     *  @param  sql sql语句
     *  @return  执行结果
     *  @throws  SQLException SQL异常
      */
     public   static   int  execute( final  String sql)  throws  SQLException  {
         final  LinkedList list  =   new  LinkedList();
        list.add(sql);
         return  execute(list)[ 0 ];
    }

     /**
     * <p>执行插入、更新和删除操作的，某一条SQL语句，支持事务的回滚</p>
     *
     *  @param  sql sql语句
     *  @param  con 数据库连接
     *  @return  执行结果
     *  @throws  SQLException SQL异常
      */
     public   static   int  execute( final  String sql,  final  Connection con)  throws  SQLException  {
         final  LinkedList list  =   new  LinkedList();
        list.add(sql);
         return  execute(list, con,  true )[ 0 ];
    }

     /**
     * <p>执行插入、更新和删除操作的，某一条SQL语句，支持事务的回滚</p>
     *
     *  @param  sql        sql语句
     *  @param  con        数据库连接
     *  @param  needCommit 需要提交
     *  @return  执行结果
     *  @throws  SQLException SQL异常
      */
     public   static   int  execute( final  String sql,  final  Connection con,  final   boolean  needCommit)  throws  SQLException  {
         final  LinkedList list  =   new  LinkedList();
        list.add(sql);
         return  execute(list, con, needCommit)[ 0 ];
    }

     /**
     * <p>执行插入、更新和删除操作的若干条SQL语句，支持事务的回滚，</p>
     * <p>Collection是一个接口，凡是实现了这个接口的都可以使用，</p>
     * <p>比如说LinkedList、ArrayList、List、HashMap，Vector和HashTable</p>
     * <p>不再推荐使用，LinkedList的添加删除性能非常好，本质上是个双向链表，</p>
     * <p>可以双向搜索。</p>
     *
     *  @param  collect SQL语句集
     *  @return  执行结果
     *  @throws  SQLException SQL异常
      */
     public   static   int [] execute( final  Collection collect)  throws  SQLException  {
         return  execute(collect,  null ,  true );
    }

     /**
     * <p>执行插入、更新和删除操作的若干条SQL语句，支持事务的回滚，</p>
     * <p>Collection是一个接口，凡是实现了这个接口的都可以使用，</p>
     * <p>比如说LinkedList、ArrayList、List、HashMap，Vector和HashTable</p>
     * <p>不再推荐使用，LinkedList的添加删除性能非常好，本质上是个双向链表，</p>
     * <p>可以双向搜索。</p>
     *
     *  @param  collect SQL语句集
     *  @param  con     数据库连接
     *  @return  执行结果
     *  @throws  SQLException
      */
     public   static   int [] execute( final  Collection collect,  final  Connection con)  throws  SQLException  {
         return  execute(collect, con,  true );
    }

     /**
     * <p>执行插入、更新和删除操作的若干条SQL语句，支持事务的回滚，</p>
     * <p>Collection是一个接口，凡是实现了这个接口的都可以使用，</p>
     * <p>比如说LinkedList、ArrayList、List、HashMap，Vector和HashTable</p>
     * <p>不再推荐使用，LinkedList的添加删除性能非常好，本质上是个双向链表，</p>
     * <p>可以双向搜索。</p>
     *
     *  @param  collect    SQL语句集
     *  @param  conn       数据库连接
     *  @param  needCommit 需要提交
     *  @return  执行结果
     *  @throws  IllegalArgumentException 如果不提交而且参数con为空，将抛出IllegalArgumentException
     *  @throws  SQLException
      */
     private   static   int [] execute( final  Collection collect,  final  Connection conn,  final   boolean  needCommit)  throws  SQLException  {
         if  ( ! needCommit  &&  conn  ==   null )  {
             throw   new  IllegalArgumentException(errPrefix  +   "  : conn is null! " );
        }
         if  (collect  ==   null   ||  collect.isEmpty())  {
             return   null ;
        }
        Connection con  =   null ;
        Statement stmt  =   null ;
         int [] ret  =   new   int [collect.size()];
         try   {
            con  =  conn  ==   null   ?  DBSql.getCon() : conn;
            stmt  =  con.createStatement();
             if  (con.getAutoCommit())  {
                con.setAutoCommit( false );
            }
            String sql  =   "" ;
             try   {
                 int  i  =   0 ;
                 final  Iterator it  =  collect.iterator();
                 while  (it.hasNext())  {
                    sql  =  it.next().toString();
                    ret[i ++ ]  =  stmt.executeUpdate(sql);
                     // aban add start
              System.out.print(sql + " ;\n " );
               // aban add end
          }
                 if  (needCommit)  {
                    con.commit();
                }
            }   catch  (SQLException ex)  {
                 if  (needCommit)  {
                     // 事务回滚
                    System.out.println(errPrefix  +   "  : execute:开始事务回滚 " );
                     try   {
                        con.rollback();
                    }   catch  (SQLException e)  {
                        System.out.println(errPrefix  +   "  : DBPool.execute():事务回滚中断 " );
                    }
                }
                System.out.println(errPrefix  +   "  : execute: "   +  ex  +   " .\r\nexecute:sql = \r\n "   +  sql);
                 throw  ex;
            }
             if  (needCommit)  {
                con.setAutoCommit( true );
            }
             return  ret;
        }   finally   {
             if  (conn  ==   null )  {
                freeResource( null , stmt, con);
            }   else   {
                freeResource( null , stmt);
            }
        }
    }

     /**
     * 执行若干条SQL语句（SQL语句类型见JDKAPI文档：java.sql.Statement.executeUpdate()）
     *
     *  @param  collect SQL语句集
     *  @param  con     数据库连接
     *  @return  执行结果
     *  @throws  SQLException
     *  @throws  IllegalArgumentException 如果参数con为空，将抛出IllegalArgumentException
      */
     private   static   int [] uncommittedExecute( final  Collection collect,  final  Connection con)  throws  SQLException, IllegalArgumentException  {
         return  execute(collect, con,  false );
    }

     /**
     * 执行一条SQL语句（SQL语句类型见JDKAPI文档：java.sql.Statement.executeUpdate()）
     *
     *  @param  sql SQL语句
     *  @param  con 数据库连接
     *  @return  执行结果
     *  @throws  SQLException
     *  @throws  IllegalArgumentException 如果参数con为空，将抛出IllegalArgumentException
      */
     public   static   int  uncommittedExecute( final  String sql,  final  Connection con)  throws  SQLException, IllegalArgumentException  {
         final  LinkedList list  =   new  LinkedList();
        list.add(sql);
         return  uncommittedExecute(list, con)[ 0 ];
    }

     /**
     * <p>把ResultSet中的信息按顺序全部复制到ArrayList中,</p>
     * <p>是两层结构二位表的结构。</p>
     * <p>调用此方式时要注意关闭ResultSet类型的rs和</p>
     * <p>Statement类型的statement,不推荐直接使用</p>
     *
     *  @param  rs 要处理的集合
     *  @return  处理后的ArrayList
     *  @throws  SQLException
      */
     private   static  ArrayList resToList( final  ResultSet rs)  throws  SQLException  {
         final   int  column  =  rs.getMetaData().getColumnCount();
         final  LinkedList list  =   new  LinkedList();
        String temp;
         while  (rs.next())  {
             final  ArrayList subList  =   new  ArrayList(column);
             // 将结果集的每行的几项按顺序存入向量，然后是下一行
             for  ( int  i  =   1 ; i  <=  column; i ++ )  {
                temp  =  rs.getString(i);
                 if  (temp  ==   null )  {
                    temp  =   "" ;
                }
                subList.add(temp.trim());
            }
            list.add(subList);
        }
         return   new  ArrayList(list);
    }

     /**
     * <p>把ResultSet中的信息按顺序全部复制到ArrayList中,</p>
     * <p>一层结构。</p>
     * <p>调用此方式时要注意关闭ResultSet类型的rs和</p>
     * <p>Statement类型的statement,不推荐直接使用</p>
     *
     *  @param  rs 要处理的集合
     *  @return  处理后的ArrayList
     *  @throws  SQLException
      */
     private   static  ArrayList resToOneList( final  ResultSet rs)  throws  SQLException  {
         final   int  column  =  rs.getMetaData().getColumnCount();
         final  LinkedList list  =   new  LinkedList();
        String temp;
         while  (rs.next())  {
             for  ( int  i  =   1 ; i  <=  column; i ++ )  {
                 // 将结果集按顺序存入向量
                temp  =  rs.getString(i);
                 if  (temp  ==   null )  {
                    temp  =   "" ;
                }
                list.add(temp.trim());
            }
        }
         return   new  ArrayList(list);
    }

     /**
     * <p>把ResultSet中的信息按顺序全部复制到ArrayList中,</p>
     * <p>是两层结构二位表的结构。</p>
     * <p>调用此方式时要注意关闭ResultSet类型的rs和</p>
     * <p>Statement类型的statement,不推荐直接使用</p>
     *
     *  @param  rs         要处理的集合
     *  @param  beginIndex 起始位置，从1开始，不用担心越界
     *  @param  num        个数，不用担心越界
     *  @param  size       记录数
     *  @return  处理后的ArrayList
     *  @throws  SQLException
      */
     private   static  ArrayList resToList( final  ResultSet rs,  final   int  beginIndex,  final   int  num,  final   int  size)  throws  SQLException  {
         final   int  column  =  rs.getMetaData().getColumnCount();
         final  ArrayList list  =   new  ArrayList(size);
        String temp;
        rs.absolute(beginIndex);
         for  ( int  i  =  beginIndex; i  <  beginIndex  +  num; i ++ )  {
             final  ArrayList subList  =   new  ArrayList(column);
             // 将结果集的每行的几项按顺序存入向量，然后是下一行
             for  ( int  j  =   1 ; j  <=  column; j ++ )  {
                temp  =  rs.getString(j);
                subList.add(temp  ==   null   ?   ""  : temp.trim());
            }
            list.add(subList);
            rs.next();
        }
         return  list;
    }

     /**
     * <p>把ResultSet中的信息按顺序全部复制到ArrayList中,</p>
     * <p>一层结构。</p>
     * <p>调用此方式时要注意关闭ResultSet类型的rs和</p>
     * <p>Statement类型的statement,不推荐直接使用</p>
     *
     *  @param  rs         要处理的集合
     *  @param  beginIndex 起始位置，从1开始，不用担心越界
     *  @param  num        个数，不用担心越界
     *  @param  size       记录数
     *  @return  处理后的ArrayList
     *  @throws  SQLException
      */
     private   static  ArrayList resToOneList( final  ResultSet rs,  final   int  beginIndex,  final   int  num,  final   int  size)  throws  SQLException  {
         final   int  column  =  rs.getMetaData().getColumnCount();
         final  ArrayList list  =   new  ArrayList(size  *  column);
        String temp;
        rs.absolute(beginIndex);
         for  ( int  i  =  beginIndex; i  <  beginIndex  +  num; i ++ )  {
             for  ( int  j  =   1 ; j  <=  column; j ++ )  {
                 // 将结果集按顺序存入向量
                temp  =  rs.getString(j);
                list.add(temp  ==   null   ?   ""  : temp.trim());
            }
            rs.next();
        }
         return  list;
    }

     /**
     * <p>把ResultSet中第一行的信息按顺序全部复制到ArrayList中,</p>
     * <p>一层结构。</p>
     * <p>调用此方式时要注意关闭ResultSet类型的rs和</p>
     * <p>Statement类型的statement,不推荐直接使用</p>
     *
     *  @param  rs 要处理的集合
     *  @return  处理后的ArrayList
     *  @throws  SQLException
      */
     private   static  ArrayList resToFirstList( final  ResultSet rs)  throws  SQLException  {
         final   int  column  =  rs.getMetaData().getColumnCount();
         final  ArrayList list  =   new  ArrayList( 1 );
        String temp;
         if  ( ! rs.next())  {
             return   new  ArrayList();
        }
         for  ( int  i  =   1 ; i  <=  column; i ++ )  {
             // 将结果集按顺序存入向量
            temp  =  rs.getString(i);
            list.add(temp  ==   null   ?   ""  : temp.trim());
        }
         return  list;
    }

     /**
     * <p>释放相关资源</p>
     *
     *  @param  rs   ResultSet
     *  @param  stmt Statement
      */
     private   static   void  freeResource( final  ResultSet rs,  final  Statement stmt)  {
        freeResource(rs, stmt,  null );
    }

     /**
     * <p>释放相关资源</p>
     *
     *  @param  rs   ResultSet
     *  @param  stmt Statement
     *  @param  con  Connection
      */
//     private static void freeResource(final ResultSet rs, final Statement stmt, final Connection con) {
      public   static   void  freeResource( final  ResultSet rs,  final  Statement stmt,  final  Connection con)  // aban change private to public
      {
         if  (rs  !=   null )  {
             try   {
                rs.close();
            }   catch  (SQLException e)  {
                e.printStackTrace();
            }
        }
         if  (stmt  !=   null )  {
             try   {
                stmt.close();
            }   catch  (SQLException e)  {
                e.printStackTrace();
            }
        }
         if  (con  !=   null )  {
            DBSql.freeConnection(con);
        }
    }     
      public   static   void  freeConnection( final  Connection connection)  {
          if  (connection  !=   null )  {
              try   {
                 connection.close();
             }   catch  (SQLException e)  {
                 e.printStackTrace();
             }
         }
     }
}



/////////////////
//////////////////       
import java.io.Reader;
import java.sql.*;
import javax.servlet.ServletRequest;
import javax.servlet.http.HttpServletRequest;
import oracle.jdbc.driver.OracleResultSet;
import oracle.sql.CLOB;

public class Db_sql
{

    private String host;
    private String port;
    private String database;
    private String user;
    private String password;
    private String sid;
    private boolean bAutoCommit;
    public ResultSet result;
    public Statement stmt;
    public int affectedRows;
    public Connection conn;
    private boolean isClosed;
    private DBConnectionManager connMgr;

    /**
     * 构造函数，new Db_sql 的时候执行，调用 connect() 连接ORACLE数据库
     */
    public Db_sql(String s, String s1, String s2, String s3, String s4)
        throws Exception
    {
        isClosed = false;
        host = s.trim();
        port = s1.trim();
        sid = s2.trim();
        user = s3.trim();
        password = s4.trim();
        connMgr = DBConnectionManager.getInstance();
        connect();
    }

    /**
     * 连接ORACLE数据库
     */
    public boolean connect()
        throws Exception
    {
        String s = "jdbc:oracle:thin:@" + host + ":" + port + ":" + sid;
        conn = connMgr.getConnection(user, s, user, password);
        return true;
    }

    /**
     * 是否自动 COMMIT 
     */
    public void setAutoCommit(boolean flag)
        throws SQLException
    {
        bAutoCommit = flag;
        conn.setAutoCommit(flag);
    }

    /**
     * 没有设置成自动 COMMIT ，调用该方法才会 COMMIT 
     */
    public void commit()
        throws SQLException
    {
        if(!bAutoCommit)
            conn.commit();
    }

    /**
     * 没有设置成自动 COMMIT ，调用该方法才会 ROLL BACK 
     */
    public void rollback()
        throws SQLException
    {
        if(!bAutoCommit)
            conn.rollback();
    }

    /**
     * 执行 SQL ，返回执行结果 TRUE/FALSE
     */
    public ResultSet query(String s)
        throws Exception
    {
        if(stmt == null)
            stmt = conn.createStatement();
        if(result != null)
        {
            result.close();
            result = null;
        }
        result = stmt.executeQuery(s);
        return result;
    }

    public void queryLarge(String s, String s1)
        throws Exception
    {
        stmt.execute(s);
        ResultSet resultset = stmt.getResultSet();
        if(resultset.next())
        {
            CLOB clob = ((OracleResultSet)resultset).getCLOB(1);
            clob.putChars(1L, s1.toCharArray());
        }
        resultset.close();
    }

    /**
     * 把结果集里的指针下移一位
     */
    public boolean next()
        throws SQLException
    {
        return result.next();
    }

    /**
     * 取得当前记录的 INT 类型字段值，前后去空格
     */
    public int getInt(String s)
        throws SQLException
    {
        return result.getInt(s.trim());
    }

    /**
     * 取得当前记录的 STRING 类型字段值，前后去空格
     */
    public String getString(String s)
        throws SQLException
    {
        return result.getString(s.trim());
    }

    /**
     * 取得当前记录的 SHORT 类型字段值，前后去空格
     */
    public short getShort(String s)
        throws SQLException
    {
        return result.getShort(s.trim());
    }


    /**
     * 取得当前记录的 LONG 类型字段值，前后去空格
     */
    public long getLong(String s)
        throws SQLException
    {
        return result.getLong(s.trim());
    }


    /**
     * 取得当前记录的 DATE 类型字段值，前后去空格
     */
    public Date getDate(String s)
        throws SQLException
    {
        return result.getDate(s.trim());
    }


    /**
     * 取得当前记录的 TIME 类型字段值，前后去空格
     */
    public Time getTime(String s)
        throws SQLException
    {
        return result.getTime(s.trim());
    }

    /**
     * 取得当前记录的 FLOAT 类型字段值，前后去空格
     */
    public float getFloat(String s)
        throws SQLException
    {
        return result.getFloat(s.trim());
    }

    /**
     * 取得当前记录的 DOUBLE 类型字段值，前后去空格
     */
    public double getDouble(String s)
        throws SQLException
    {
        return result.getDouble(s.trim());
    }

    /**
     * 取得当前记录的 BOOLEAN 类型字段值，前后去空格
     */
    public boolean getBoolean(String s)
        throws SQLException
    {
        return result.getBoolean(s.trim());
    }

    /**
     * 取得当前记录的 CLOB 类型字段值
     */
    public String getText(String s)
        throws SQLException
    {
        String s1 = "";
        char ac[] = new char[200];
        CLOB clob = (CLOB)result.getObject(s);
        if(clob == null)
            return null;
        Reader reader = clob.getCharacterStream();
        int i;
        try
        {
            while((i = reader.read(ac, 0, 200)) != -1) 
                s1 = s1 + new String(ac, 0, i);
        }
        catch(Exception exception1)
        {
            throw new SQLException(exception1.getMessage());
        }
        finally
        {
            try
            {
                reader.close();
            }
            catch(Exception _ex) { }
        }
        return s1;
    }

    /**
     * 关闭数据库连接，执行 COMMIT，RELEASE 动作
     */
    public boolean close()
        throws SQLException
    {
        if(result != null)
        {
            result.close();
            result = null;
        }
        if(stmt != null)
        {
            stmt.close();
            stmt = null;
        }
        conn.setAutoCommit(true);
        connMgr.freeConnection(user, conn);
        connMgr.release(user);
        isClosed = true;
        return true;
    }

    /**
     * 没有调用 close() 时，执行 close() 
     */
    protected void finalize()
        throws SQLException
    {
        if(!isClosed)
            close();
    }

    /**
     * 取得 HTTP 参数值，所有得到的值都做了
     * String (request.getParameter(s.trim()).trim().getBytes("ISO8859_1"), "GB2312") 处理
     */
    public static String getParameter(HttpServletRequest httpservletrequest, String s)
    {
        try
        {
            if(httpservletrequest.getParameter(s.trim()) != null)
                return new String(httpservletrequest.getParameter(s.trim()).trim().getBytes("ISO8859_1"), "GB2312");
            else
                return null;
        }
        catch(Exception _ex)
        {
            return httpservletrequest.getParameter(s.trim());
        }
    }


}

posted on 2006-05-12 00:47 record java and net 阅读(690) 评论(0)  编辑  收藏 所属分类: 常用配置代码


只有注册用户登录后才能发表评论。
网站导航:
 

导航

常用链接

留言簿(44)

新闻档案

2.动态语言

3.工具箱

9.文档教程

友情链接

搜索

最新评论