HSQL测试

采用C/S的模式操作HSQL数据库：
    1、建立数据库的目录：
       e:\hsqldb 目录下建立mydb.properties 和mydb.script文件，如果目录下不建立数据库文件则会自动产生这些文件；如果需要在建立库的同时就让数据库
       的对象（表等）建立好，则需要在mydb.script中写入这些执行的脚本语句，数据库启动时会读取脚本文件并执行这些脚本语句；
    2、使用命令行的方式启动后台HSQL数据库：
       java -ms512M -mx1024M  -cp hsqldb.jar org.hsqldb.Server -database.0 e:\hsqldb\mydb -dbname.0 mydb -port 9002 
       这样将以mydb作为数据库名启动数据库；端口为9002；
    3、启动查看管理工具：
       java -cp hsqldb.jar org.hsqldb.util.DatabaseManager
       启动后进入管理界面：选择HSQL Dabase Engine Server以客户端服务器方式进行连接；
       org.hsqldb.jdbcDriver
       jdbc:hsqldb:hsql://localhost:9002/mydb   这里要指定后台数据库监听的端口和数据库名；
       其他使用自动的值连接即可，这时可以进入到库的管理界面执行各种SQL语句；
    4、启动客户端程序
       java -cp  D:\hsql173\hsqldb\lib\hsqldb.jar;. com.guo.TestDB 启动测试的例子程序；
       源程序：参照hsql的demo
       package com.guo;

       import java.sql.Connection;
       import java.sql.DriverManager;
       import java.sql.ResultSet;
       import java.sql.ResultSetMetaData;
       import java.sql.SQLException;
       import java.sql.Statement;
      
       /**
        * Title: Testdb Description: simple hello world db example of a standalone
        * persistent db application * every time it runs it adds four more rows to
        * sample_table it does a query and prints the results to standard out * Author:
        * Karl Meissner [e-mail]
        */
       public class TestDB {
        Connection conn;
      
        // we dont want this garbage collected until we are done
        public TestDB(String db_file_name_prefix) throws Exception {
         Class.forName("org.hsqldb.jdbcDriver");
         conn = DriverManager.getConnection("jdbc:hsqldb:hsql://localhost:9002/" + db_file_name_prefix, "sa", "");
        }
      
        public void shutdown() throws SQLException {
         conn.close();
        }
      
        // use for SQL command SELECT
        public synchronized void query(String expression) throws SQLException {
         Statement st = null;
         ResultSet rs = null;
         st = conn.createStatement();
         rs = st.executeQuery(expression); // run the query
         dump(rs);
         st.close();
        }
      
        // use for SQL commands CREATE, DROP, INSERT and UPDATE
        public synchronized void update(String expression) throws SQLException {
         Statement st = null;
         st = conn.createStatement(); // statements
         int i = st.executeUpdate(expression); // run the query
         if (i == -1) {
          System.out.println("db error : " + expression);
         }
         st.close();
         conn.commit();
        }
        //采用批量方式
       public synchronized void updateBatch() throws SQLException {
        PreparedStatement st = null;
        st = conn.prepareStatement("insert into sample_table values(?,?)");
        int commitnum = 0;
        for (int i = 0; i < 100000; i++) {
         st.setString(1, "Ford");
         st.setInt(2, 100);
         st.addBatch();
         st.setString(1, "Toyota");
         st.setInt(2, 200);
         st.addBatch();
         st.setString(1, "Honda");
         st.setInt(2, 300);
         st.addBatch();
         st.setString(1, "GM");
         st.setInt(2, 400);
         st.addBatch();
         commitnum = commitnum+1;
         if(commitnum>5000){
          commitnum=0;
          st.executeBatch();
          conn.commit();
         }
        }
        st.close();
        conn.commit();
       }      
        public static void dump(ResultSet rs) throws SQLException {
         ResultSetMetaData meta = rs.getMetaData();
         int colmax = meta.getColumnCount();
         int i;
         Object o = null;
         for (; rs.next();) {
          for (i = 0; i < colmax; ++i) {
           o = rs.getObject(i + 1);
           System.out.print(o.toString() + " ");
          }
          System.out.println(" ");
         }
        }
      
        public static void main(String[] args) {
         TestDB db = null;
         try {
          db = new TestDB("mydb");
         } catch (Exception ex1) {
          ex1.printStackTrace(); // could not start db
          return; // bye bye
         }
         try {
          db.update("DROP TABLE sample_table");
          db.update("CREATE TABLE sample_table(str_col VARCHAR(256),num_col INTEGER)");
         } catch (SQLException ex2) {
          ex2.printStackTrace();
         }
         try {
          System.out.println (new java.util.Date());
          for (int i = 0; i < 100000; i++) {
           db.update("INSERT INTO sample_table(str_col,num_col) VALUES('Ford', 100)");
           db.update("INSERT INTO sample_table(str_col,num_col) VALUES('Toyota', 200)");
           db.update("INSERT INTO sample_table(str_col,num_col) VALUES('Honda', 300)");
           db.update("INSERT INTO sample_table(str_col,num_col) VALUES('GM', 400)");
          }
          System.out.println (new java.util.Date());
          // do a query
          //db.query("SELECT * FROM sample_table WHERE num_col < 250");
          // at end of program
          db.shutdown();
         } catch (SQLException ex3) {
          ex3.printStackTrace();
         }
        } // main()
       } // class Testdb

     5、执行结果分析；
        采用单条写入方式HSQL用时：
            Wed Jul 04 14:29:39 CST 2007
            Wed Jul 04 14:31:01 CST 2007
        这里的测试程序执行了40万条数据的写入，用时2分30妙（可以和直接ORACLE的进行对比）
        采用同样的方式使用ORACLE的连接
          Class.forName("oracle.jdbc.driver.OracleDriver");
        conn = DriverManager.getConnection("jdbc:oracle:thin:@192.168.5.77:1521:TQS_DEV", "wad", "wad");
      执行时间没有结果6000条就2分多钟了（被迫中途停止）
     
      采用批量的写入方式HSQL用了几秒钟：
          Wed Jul 04 16:21:32 CST 2007
            Wed Jul 04 16:21:38 CST 2007
        采用ORACLE的批量写入方式同样很快：
            Wed Jul 04 16:24:56 CST 2007
            Wed Jul 04 16:24:58 CST 2007
      如果也是可以采用批量方式的话根本就没有必要在用内存数据库了；
     
        每次业务运行后都有日志文件和SCRIPT文件，当数据库启动时自动将原有的数据导入非常的快，可以进行统计查询处理；

评论

1 楼 chris_lve 2007-09-03  

有没有把properties中的memory改为cached啊??