1、簡介：html
hsql數據庫是一款純Java編寫的免費數據庫，許但是BSD-style的協議，若是你是使用Java編程的話，不凡考慮一下使用它，相對其java
他數據庫來講，其體積小，才563kb。僅一個hsqldb.jar文件就包括了數據庫引擎，數據庫驅動， 還有其餘用戶界面操做等內容。在mysql
Java開源世界裏，hsql是極爲受歡迎的（就Java自己來講），JBoss應用程序服務器默認也提供了這個數據庫引 擎。因爲其體積小的git
緣由，又是純Java設計，又支持SQL99，SQL2003大部分的標準，因此也是做爲商業應用程序展現的一種選擇。請到如下地址下載hsqlweb
： http://prdownloads.sourceforge.net/hsqldb/hsqldb_1_7_3_3.zip?downloadspring
2、使用hsql數據庫：sql
一、hsql數據庫引擎有幾種服務器模式：經常使用的Server模式、WebServer模式、Servlet模式、Standlone模式、Memory-Only數據庫。數據庫
二、最爲經常使用的Server模式：express
1)首先卻換到lib文件夾下，運行java -cp hsqldb.jar org.hsqldb.Server -database.0 db/mydb -dbname.0 xdb，xdb至關於數據庫別名，執行命令後後會在lib目錄下生成一個db文件夾，將會在db文件夾下建立一個數據庫mydb，別名（用於訪問數據庫）是xdb，若是存在mydb數據庫，將會打開它。編程
2)在lib文件夾目錄下運行數據庫界面操做工具：java -cp hsqldb.jar org.hsqldb.util.DatabaseManager
在Type 選項裏選上相應的服務器模式，這裏選擇HSQL Database Engine Server模式；Driver不用修改；URL修改成jdbc:hsqldb:hsql://localhost/xdb （主要這裏xdb就是上面咱們設置的別名）;user裏設置用戶名，第一次登陸時，設置的是管理員的用戶名，password設置密碼。而後點擊Ok。
3)第一次運行數據庫引擎，建立數據庫完畢。好了，你能夠打開db文件夾，會發現裏面多了幾個文件。
mydb.properties文件：是關於數據庫的屬性文件。
mydb.script：hsql主要保存的表（這裏按hsql的說法是Memory表，就是最爲經常使用的），裏面的格式都是文本格式，能夠用文本查看，裏面的語句都是sql語句，熟悉sql語句的話，你也能夠手動修改它。每次運行數據庫引擎的話都是從這裏加載進內存的。
mydb.lck表示數據庫處於打開狀態。
其餘的請參看hsqldb包裏的手冊。
三、WebServer模式和Server運行模式基本同樣，只是支持了Http等協議，主要用於防火牆，默認端口是9001。啓動Server，java -cp hsqldb.jar org.hsqldb.WebServer ...剩餘的和上面的一致。
四、Servlet模式能夠容許你經過Servlet容器來訪問數據庫，請查看hsqlServlet.java的源代碼，和WebServer相似。
五、另外一個值得思考的模式是Standalone模式：不能經過網絡來訪問數據庫，主要是在一個JVM中使用，那樣的話，訪問的速度會更加快。雖然文檔裏面提到主要是用於開發時使用，可是咱們能夠假設一下，該方法不須要一個引擎類的東西，而相似於打開文件的方式，返回一個Connection對象：
Connection c = DriverManager.getConnection("jdbc:hsqldb:file:mydb", "sa", "");
將 會在當前目錄找到mydb數據庫相關文件，打開並返回一個Connection對象。該方式有點好處就是能夠不使用引擎，在須要的時候操做數據。因此那些 對數據庫不是特別有要求的，但又須要一個操做數據庫的方式的話，可使用這種方法。對於那些不想額外在數據庫引擎花費金錢的話，可使用這種方法。可是不 推薦使用該方法。記得Hibernate裏SessionFactory可使用openSession(Connecttion c)來得到一個Session對象的，所以，在測試或者實際應用的話均可以這樣使用。
六、Memory-Only 數據庫：顧名思義，主要是內存中使用，不用於保存數據。能夠用於在內存中交換數據。
3、具體的連接與操做的話，和通常的JDBC操做同樣。而相應的Server模式的話，鏈接地址主要你運行數據庫界面操做工具時，在URL一欄時默認已經設好了。
---------------------------------------------------------------------------------------------
1.將hsqldb.jar拷貝到工程WEB-INF/lib下
2.開啓兩個命令行窗口,進入工程 WEB-INF/lib目錄
cd C:/eclipseworkspace/TestFrame/WebContent/WEB-INF/lib(假設工程目錄爲此)
3.分別在命令行中輸入命令,啓動數據庫服務器和客戶端:
服務器:java -classpath hsqldb.jar org.hsqldb.Server
// 客戶端:java -classpath hsqldb.jar org.hsqldb.util.DatabaseManagerSwing
4,設定鏈接數據庫的相關參數
driverClassName=org.hsqldb.jdbcDriver
url=jdbc:hsqldb:hsql://localhost
若是使用hibernate,須要注意下面的參數:
hibernate.dialect=org.hibernate.dialect.HSQLDialect
5.測試jdbc鏈接hsqldb.jar數據庫程序:
package com.util;
import java.sql.*;
public class DBWork {
public static void main(String args[]){
try{
Class.forName("org.hsqldb.jdbcDriver");
Connection conn = DriverManager.getConnection("jdbc:hsqldb:hsql://localhost", "sa", "");
System.out.println("conn = " + conn);
} catch(Exception e){
e.printStackTrace();
}
}
}
6.spring+hibernate中,applicationContext.xml中配置:
<bean
class="org.springframework.jdbc.datasource.DriverManagerDataSource" id="dataSource">
<property name="driverClassName">
<value>org.hsqldb.jdbcDriver</value>
</property>
<property name="url">
<value>jdbc:hsqldb:hsql://localhost</value>
</property>
<property name="username">
<value>sa</value>
</property>
<property name="password">
<value/>
</property>
</bean>
<bean
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean" id="sessionFactory">
<property name="dataSource">
<ref local="dataSource"/>
</property>
<property name="mappingResources">
<list>
<value>com/hibernate/UserInfo.hbm.xml</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.HSQLDialect</prop>
<prop key="hibernate.show_sql">true</prop>
</props>
</property>
</bean>
HSQLDB是一個輕量級的純Java開發的開放源代碼的關係數據庫系統，其體積小，佔用空間小，使用簡單，支持內存運行方式等特色。能夠在
http://sourceforge.net/projects/hsqldb/files/
下載最新的HSQLDB版本。我這裏下載的是 HSQLDB 2.2.7 版本。下載完以後，把它解壓到任一目錄下，如 E:\hsqldb 下，完成安裝工做。
Hsqldb有四種運行模式：
1、內存（Memory-Only）模式：全部的數據都將在內存中完成，若是程序退出，則相應的數據也將同時被銷燬。鏈接JDBC的實例爲：jdbc:hsqldb:mem:dbname
2、進行（In-Process）模式：此模式從應用程序啓動數據庫，因爲全部的數據都將寫到文件中，因此，即便程序退出，數據也不會被銷燬。In-Process 不須要另外啓動，能夠經過
DriverManager.getConnection("jdbcUriName","username","password");
方式便可啓動數據庫。鏈接 JDBC 的實例爲：
jdbc:hsqldb:file:/E:/hsqldb/data/dbname
jdbc:hsqldb:file:/opt/db/dbname
jdbc:hsqldb:file:dbname
3、服務器模式：此模式下 HSQLDB 跟其它數據庫服務器同樣，須要經過服務器的形式來進行啓動，能夠經過
java -classpath ../lib/hsqldb.jar org.hsqldb.server.WebServer –database.0 testdb –dbname.0 testdbName
的命令啓動一個守護進程。鏈接 JDBC 的實例爲：
jdbc:hsqldb:hsql://localhost:port/dbname
4、Web服務器模式：此模式以WEB服務器的形式啓動，並經過HTTP協議接受客戶端命令。從1.7.2版本開始，Web服務器模式的 HSQLDB 開始支持事務處理。能夠經過
java -classpath ../lib/hsqldb.jar org.hsqldb.WebServer –database.0 testdb –dbname.0 testdbname
的命令來啓動。
重點討論 hsqldb 服務器模式的啓動方法和鏈接和實際java程序的JDBC鏈接狀況。假設JDK已經安裝到機器上，環境變量等都正確設置。
首先在 E:\hsqldbTest 目錄下創建兩個子目錄，data和lib目錄，data用來存放數據，lib用來管理jar包。將解壓以後的hsqldb中的lib目錄下的 hsqldb.jar 文件拷貝到 E:\hsqldbTest\lib 目錄下。
1．在hsqldbTest目錄下建立 runServer.bat 文件，其內容爲：
cd ..\data
@java -classpath ../lib/hsqldb.jar org.hsqldb.server.Server
2．保存 runServer.bat 文件，並雙擊運行該文件，此時回彈出命令行窗口，以下圖，表示已啓動 HSQLDB 數據庫。
此時，在data目錄下產生了三個文件，如：
test.lck ——標識數據庫鎖狀態。
test.log ——運行數據庫產生的log信息，它將記錄每個運行和用戶操做環節。
test.properties——數據庫的配置信息，包括分配的內存大小等，可更具須要修改。
注：若是在命令行窗口中按下[Ctrl] + [C]組合鍵，數據庫將退出並關閉。
在作第三步時，千萬不能關閉 runServer.bat
3．再建立 runManager.bat 文件，用來啓動圖形界面管理工具，其內容爲：
cd ..\data
@java -classpath ..\lib\hsqldb.jar org.hsqldb.util.DatabaseManager
4．保存 runManager.bat 文件，並雙擊文件，此時回彈出圖形界面（注意，在進行這一不以前，必須確保第二步已執行），以下圖。
Recent：將會列出最近的數據庫配置
Setting Name: 設置名稱，這裏不須要填寫
Type：選擇服務器模式（HSQL Database Engine Server）
Driver：驅動名稱，不須要修改
URL：JDBC鏈接，無需修改
User：用戶名,根據須要設置
Password：密碼，根據須要設置
5．點擊【OK】按鈕，便可鏈接到 test 數據庫。以下圖所示。
此時，咱們能夠在窗口中建立表等操做，例如，咱們建立一個TBL_USERS的表。在菜單欄中選擇 COMMAND -> CREATE TABLE命令，此時在右下文本框中顯示建立表的命令，包括各式，支持的類型等。咱們建立的 TBL_USERS 表結構以下圖所示：
CREATE TABLE TBL_USERS(
ID INTEGER NOT NULL PRIMARY KEY,
FIRST_NAME VARCHAR(20),
LAST_NAME VARCHAR (30),
LOGIN_DATE DATE
)
6．點擊【Execute】按鈕，若是無語法錯誤，SQL語句將正常執行，此時，選擇菜單欄中的 View -> Refresh Tree 命令，左側欄中將顯示建立的 TBL_USERS 。以下圖所示。而且查看 test.log 文件，建立表的過程都將所有記錄。
7．另外還能夠用 DatabaseManagerSwing 工具啓動圖形界面。建立 runManagerSwing.bat 文件，內容爲：
cd ..\data
@java -classpath ..\lib\hsqldb.jar org.hsqldb.util.DatabaseManagerSwing
保存文件，雙擊該文件，將啓動 Swing 圖形界面，以下圖所示，具體的操做過程和 DatabaseManager 工具相似，再也不重複。
以上就是啓動hsqldb數據庫和建立表的整個過程，其它的功能能夠經過屢次聯繫便可掌握。按照以上操做方式，hsqldb 將自動產生一個 test 的數據庫。可是有時候咱們須要本身指定數據庫，數據庫訪問名，數據庫訪問端口等，該如何實現呢，很簡單。只要在相對根目錄下建立一個 server.properties 文件便可。
建立本身制定的數據庫：
1.首先在 E:\hsqldbTest 目錄下建立一個 server.properties 文件，文件內容爲（注：在實際文件中，刪除後面的註釋內容）：
server.port = 9001 #指定端口號爲9001
server.database.0 = file:data/mydb #將在data目錄下建立mydb數據庫
server.dbname.0 = mydb #指定數據庫名，jdbc鏈接時就是用此名稱
server.silent = true
2.在 E:\hsqldbTest 目錄下建立 runServer2.bat 文件，文件內容爲
cd ..\data
@java -classpath ../lib/hsqldb.jar org.hsqldb.server.Server -port 9001 -database.0 file:../data/mydb -dbname.0 mydb
3.雙擊運行 runServer2.bat 文件，將會在data目錄下建立mydb數據庫，並啓動數據庫。
4.雙擊運行已建立好的 runManagerSwing.bat 文件，打開圖形管理界面，並設置鏈接到 mydb 數據庫中，以下圖所示：
5.配置好選項，點擊 OK 按鈕，便可鏈接到mydb數據庫，在窗口中能夠按照之前的步驟建立表，添加記錄等操做。
好了，以上就是整個 hsqldb 的安裝、啓動、建立表等的全過程，在這裏特別說明的是，hsqldb.2.2.7 是用 JDK.1.5 以上的版本的編譯的，因此，若是你使用的是低於 jdk1.5 的版本時，可能出現異常狀況，不能正常使用。另外，即便你安裝的jdk版本是1.5以上的，可能還會出現異常，該如何辦呢，此時，確保你的hsqldb是在官方網站下載的，須要檢查你的java的環境變量，因爲你的機器可能安裝有oracle，頗有可能出現問題，此時只需將 %JAVA_HOME%\bin 路徑放置在path路徑的最開頭，這樣，就不會出現異常狀況了。
接下來，咱們經過一個具體的java程序來鏈接創建好的mydb數據庫，而且在mydb數據庫中建立一個TBL_USERS的表。並插入一條記錄。
1. 在 E:\hsqldbTest 目錄下建立一個 HsqlDemo.java 文件，內容以下：
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
import org.hsqldb.jdbcDriver;
public class HsqlDemo {
public static void main(String[] args) {
try {
Class.forName("org.hsqldb.jdbcDriver");
Connection c = DriverManager.getConnection("jdbc:hsqldb:hsql://localhost:9001/mydb", "sa", "");
if (c != null) {
System.out.println("Connected db success!");
String sql = "CREATE TABLE TBL_USERS(ID INTEGER, NAME VARCHAR, BIRTHDAY DATE);";
Statement st = c.createStatement();
st.execute(sql);
sql = "INSERT INTO TBL_USERS(ID, NAME, BIRTHDAY) VALUES ('1', 'ADMIN', SYSDATE);";
st.executeUpdate(sql);
if (st != null) {
st.close();
}
c.close();
}
} catch(Exception e) {
System.out.println("ERROR:failed to load HSQLDB JDBC driver.");
e.printStackTrace();
return;
}
}
}
2.在 E:\hsqldbTest 目錄下創建一個 runJava.bat 文件，用來運行 HsqlDemo.java 內容以下：
@echo off
set path = C:\Program Files\Java\jdk1.6.0_05\bin #jdk的路徑
javac -classpath ../lib/hsqldb.jar HsqlDemo.java
java -classpath ../lib/hsqldb.jar;./ HsqlDemo # 注意./ 後面的空格，./[空格] HsqlDemo
3.肯定 mydb 數據庫已經啓動，若是沒有，運行 runServer2.bat ，啓動數據庫。
4.運行 runJava.bat 文件，運行程序，若是無異常產生，說明已正確執行，此時，能夠在 mydb.log 文件中看到建立的 TBL_USERS ，插入的記錄，固然，能夠用圖形工具查看錶。
OK，以上就是全部的hsqldb啓動過程和鏈接jdbc的過程。假設咱們須要建立/啓動一個名爲 mydb 的數據庫。 爲了操做方便等，咱們在 c:/hsqldb 目錄下建立 mydb 目錄。
1，建立 runMydb.bat 文件，文件內容爲：
java -classpath ../lib/hsqldb.jar org.hsqldb.server.Server -database mydb
或
java -classpath ../lib/hsqldb.jar org.hsqldb.server.Server -database.0 mydb -dbname.0 mydb
啓動 runMydb.bat 命令便可
2，建立 manageMydb.bat 文件，內容：
java -classpath ../lib/hsqldb.jar org.hsqldb.util.DatabaseManager -url jdbc:hsqldb:hsql://localhost/mydb
啓動 manageMydb.bat ，便可啓動HSQLDB的圖形界面管理工具
Hsqldb 的主要工具類：
org.hsqldb.util.DatabaseManager
org.hsqldb.util.DatabaseManagerSwing
org.hsqldb.util.Transfer
org.hsqldb.util.QueryTool
org.hsqldb.util.SqlTool
使用 JDBC 鏈接 HSQLDB 數據庫
Java 語言經過 JDBC 使用 HSQLDB 數據庫很是簡單：
1，將 hsqldb.jar 加入到classpath
2，經過 Class.forName("org.hsqldb.jdbcDriver" ); 初始化 hsqldb 的 jdbc 驅動
3，經過 DriverManager.getConnection(hsqldb-url, user, password); 取得 HSQLDB 數據庫的鏈接
使用例：
try {
Class.forName("org.hsqldb.jdbcDriver");
} catch (Exception e) {
System.out.println("ERROR:failed to load jdbc driver");
e.printStackTrace();
return;
}
Connection conn = DriverManager.getConnection("jdbc:hsqldb:hsql://localhost/mydb");
其中，jdbc:hsqldb:hsql://localhost/xdb 須要替換爲合適的 jdbc-url 。
有關JDBC-URL的詳細描述請參考HSQLDB的四種運行模式
在Hibernate裏使用HSQLDB
著名的ORM工具Hibernate也提供了對 HSQLDB 數據庫的支持。須要在Hibernage裏使用 HSQLDB ，只需在 hibernate.cfg.xml 里加入相似以下設置：
<hibernate-configuration>
<session-factory>
<property name="show_sql">true</property>
<property name="connection.driver_class">org.hsqldb.jdbcDriver</property>
<property name="connection.url">jdbc:hsqldb:hsql://localhost/mydb</property>
<property name="connection.username">SA</property>
<property name="connection.password"></property>
<property name="dialect">org.hibernate.dialect.HSQLDialect</property>
<mapping resource="Customer.hbm.xml" />
</session-factory>
</hibernate-cofiguration>
其他就跟其餘數據庫的用法同樣了，這裏再也不詳述。
HSQLDB建立數據庫和基本的數據庫訪問
1、 簡介
Hsqldb是一個純java編寫的輕量級數據庫，主要有三種運行模式：
1．Server模式
2．Standlone模式
3．Memory-Only模式
其中server模式又分爲：
1．Hsqldb Server模式
2．Hsqldb Web Server模式
3．Hsqldb Servlet模式
2、 官網和最新版本
訪問Hsqldb的官方地址：http://hsqldb.org/，下載最新的hsqldb，下載地址：
http://nchc.dl.sourceforge.net/project/hsqldb/hsqldb/hsqldb_2_1/hsqldb-2.1.0.zip，我下載時的最新版本是2.1.0。下載後解壓。
3、 使用HSQL數據庫
下面介紹一下如何建立數據庫：
1. 建立文件夾
在E盤下創建一個目錄hsqldb文件夾（這個是任意創建的，呵呵），將hsqldb.jar拷貝到裏面，而後再裏邊再創建一個data的文件夾（固然這個文件夾也是任意創建的，起其餘名字也能夠）以下圖所示：
圖0
2. 建立數據庫
進入命令提示符，進入data文件夾，輸入命令：
E:\hsqldb\data>java -cp ../hsqldb.jar org.hsqldb.Server -database mydb
這時候，data文件夾中就會出現兩個文件：mydb.log 和 mydb.properties ，也就是建立了一個名稱爲mydb的數據庫，以下圖所示。注意，這也是數據庫引擎的啓動界面，若是將其關閉，第三步不能成功，由於數據庫啓動引擎關閉了，特別要注意，呵呵。
圖1
生成的數據庫文件以下圖所示：
圖2
3. 客戶端工具
另外打開一個CMD終端，進入到E:\hsqldb\data目錄，輸入命令：java -cp ../hsqldb.jar org.hsqldb.util.DatabaseManager （注：仍是在data目錄執行這個命令），就會出現一個數據庫控制界面，如圖：（這裏選擇的是In-Memory模式，固然Server模式也能夠）
圖3
圖4
4. 建立表及插入數據
下面我們以Server運行模式爲例介紹，點擊「ok」按鈕進入系統。在腳本執行框中，輸入：
create table customer(id integer not null primary key,firstname varchar(60),lastname varchar(60));
點擊「Execute」按鈕，這樣就建立了一個名字爲customer的數據表。
再執行：
insert into customer values(1,'Anker','Jia');
點擊Execute按鈕，就插入了一條數據。
再執行：
select * from customer;
就能夠查詢出這條數據了，以下圖所示：
圖5
若是如今咱們把數據庫運行引擎關閉，即關閉圖1中所示的運行引擎。若是再次運行引擎，即：java -cp ../hsqldb.jar org.hsqldb.Server -database mydb ，就會在data文件夾中出現一個文件mydb.srcipt，這裏面保存着數據執行文件，運行時會執行這個文件中sql語句。也就是說，數據以sql的形式保存在mydb.srcipt文件裏面，再次運行引擎時，會再次插入這些保存的數據，這樣會看到上次我們創建的customer的數據表，以下圖示：
圖6
上面是啓動數據庫（包括創建）和查看的方法，供你們參考，若是要研究hibernate的一些特性，就須要像mysql，oracle等大型數據庫服務了，一個小小的jar包，就是一個數據庫，做爲測試非常方便。
5. 給數據庫起別名
建立命令：java -cp ../hsqldb.jar org.hsqldb.Server -database.0 mydb -dbname.0 sun
這時候，就給數據庫起了一個叫sun的別名，訪問時，須要在在localhost後面加一個sun，如示：jdbc:hsqldb:hsql://localhost/sun
以下圖所示：
否則，不能訪問。能夠和圖2作一下對比。
HSQL 學習筆記
1. hsql 學習 1.1. 學習目的 本文檔是針對hSQL 數據庫方面的基礎學習，爲了使項目組成員可以達到使用hSQL 數據庫的目的。 1.2. 培訓對象 開發人員 1.3. 經常使用詞及符號說明 經常使用詞： hsql：一種免費的跨平臺的數據庫系統 E:\hsqldb：表示是在dos 命令窗口下面 1.4. 參考信息 doc\guide\guide.pdf 2. HSQL 2.1. HSQL 運行工具 java -cp ../lib/hsqldb.jar org.hsqldb.util.DatabaseManager 注意hsqldb.jar 文件的文件路徑,最好能放到classpath 裏面,或者放到當前路徑下. java -cp hsqldb.jar org.hsqldb.util.DatabaseManager 2.2. 運行數據庫 啓動方式: Server Modes and In-Process Mode (also called Standalone Mode). 一個test 數據庫會包含以下文件: • test.properties • test.script • test.log • test.data • test.backup test.properties 文件包含關於數據庫的通常設置. test.script 文件包含表和其它數據庫,插入沒有緩存表的數據. test.log 文件包含當前數據庫的變動. test.data 文件包含緩存表的數據 test.backup 文件是最近持久化狀態的表的數據文件的壓縮備份文件 全部以上這個文件都是必要的,不能被刪除.若是數據庫沒有緩存表,test.data 和test.backup 文件將不會存在.另外,除了以上文件HSQLDB 數據庫能夠連接到任何文本文件,好比cvs 文件. 當操做test 數據庫的時候, test.log 用於保存數據的變動. 當正常SHUTDOWN,這個文件將被刪除. 不然(不是正常shutdown),這個文件將用於再次啓動的時候,重作這些變動.test.lck 文件也用於記錄打開的數據庫的事實, 正常SHUTDOWN,文件也被刪除.在一些狀況下,test.data.old 文件會被建立,並刪除之前的. 2.3. Server Mode java -cp ../lib/hsqldb.jar org.hsqldb.Server -database.0 file:mydb -dbname.0 xdb 命令行方式: 啓動數據,數據庫文件mydb,數據庫名稱xdb 也能夠在 server.properties 文件中定義啓動的數據庫,最多10個 例如: server.properties: server.database.0=file:E:/hsqldb/data/mydb server.dbname.0=xdb server.database.1=file:E:/hsqldb/data/testdb server.dbname.1=testdb server.database.2=mem:adatabase server.dbname.2=quickdb 啓動命令: java -cp ../lib/hsqldb.jar org.hsqldb.Server 運行結果以下 java 測試程序: package test; import junit.framework.TestCase; import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; public class TestConnect extends TestCase { Connection connection; protected void setUp() { try { Class.forName("org.hsqldb.jdbcDriver" ); connection = DriverManager.getConnection("jdbc:hsqldb:hsql://localhost/xdb","sa",""); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } public void testselect() { Statement stmt=null; ResultSet rs=null; try { stmt = connection.createStatement(); String sql ="select * from test"; rs=stmt.executeQuery( sql); while(rs.next() ) { System.out.println("id="+rs.getString("id")); System.out.println("name="+rs.getString("name")); } } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } finally { try { rs.close() ; stmt.close(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } protected void tearDown() { try { connection.close(); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } } 以上在eclipse 中測試經過. 2.4. In-Process (Standalone) Mode 不須要啓動server connection = DriverManager.getConnection("jdbc:hsqldb:file:E:/hsqldb/data/mydb","sa",""); 這樣就能夠鏈接數據庫。 只能在一個jvm 中使用，不能在多個jvm 中使用。 這種模式是在相同的jvm 下做爲你的應用程序的一部分，運行數據庫引擎。對大多數應用程序，這種模式運行會至關快，做爲數據，不須要轉換和網絡傳輸。 主要的缺點就是不可能從外面的應用程序訪問到默認數據庫，所以當你的應用運行時候，你不能經過別的工具檢查數據庫內容。在1.8.0 版本中,你能夠在相同jvm 中的線程中運行數據庫初始化，並提供外面訪問你的進程內數據庫。 推薦在開發應用中使用這種方式。 鏈接串： Windows: DriverManager.getConnection("jdbc:hsqldb:file:E:/hsqldb/data/mydb","sa",""); Unix: DriverManager.getConnection("jdbc:hsqldb:file:/opt/db/testdb","sa",""); 2.5. Memory-Only Databases 當隨即訪問內存，數據庫不固定時，能夠採用內存的方式運行數據庫，因爲沒有數據寫到硬盤上，這種方式使用在應用數據和applets 和特殊應用的內部進程中使用，URL： Connection c = DriverManager.getConnection("jdbc:hsqldb:mem:aname", "sa", ""); 2.6. Using Multiple Databases in One JVM 2.7. Different Types of Tables HSQLDB 支持 TEMP 表和三種類型的持久表（MEMORY 表, CACHED 表，TEXT表） 當使用 CREATE TABLE 命令時，Memory 表時默認類型，它們的數據總體保存在內存當中，可是任何改變它們的結構或者內容，它們會被寫到<dbname>.script 文件中。這個腳本文件在數據庫下一次打開的時候被對出，內存表從新被建立內容，根temp 表不一樣，內存表時持久化的。 CACHED 表經過CREATE CACHED TABLE 命令創建. 只有部分的它們的數據或者索引被保存在內存中，容許大表佔用幾百兆的內存空間。例外一個優勢，在數據庫引擎中，啓動大量數據的緩存表須要花費少許的時間，缺點是減慢了運行和使用Hsqldb 的速度。表相對小的時候，不要使用cache 表，在小表中使用內存數據庫。 從版本 1.7.0 之後，支持text 表，使用 CSV (Comma Separated Value) 或者其它分隔符文本文件做爲它們的數據源。你能夠特殊指定一個存在的CSV 文件，例如從其它的數據或者程序中導出文件，做爲TXT 表的數據源。 同時,你能夠指定一個空文件，經過數據庫引擎填充數據。TEXT 表將比cache 表更加效率高。Text 表能夠指向不一樣的數據文件。 * memory-only databases 數據庫只支持memory 表和cache 表，不支持text 表。 2.8. 約束和索引 HSQLDB 支持 PRIMARY KEY, NOT NULL, UNIQUE, CHECK and FOREIGN KEY 約束. 3. sql 命令 3.1. sql 支持 select top 1 * from test; select limit 0 2 * from test; DROP TABLE test IF EXISTS; 3.2. Constraints and Indexes 主健約束：PRIMARY KEY 惟一約束： 惟一索引： 外健： CREATE TABLE child(c1 INTEGER, c2 VARCHAR, FOREIGN KEY (c1, c2) REFERENCES parent(p1, p2)); 3.3. 索引和查詢速度 索引提升查詢速度，比提升排序速度。 主健和惟一所列自動建立索引，不然須要本身建立CREATE INDEX command。 索引： 惟一索引和非惟一索引 多列的索引，若是隻是使用後面的，不使用第一個，將不會條查詢速度。 (TB is a very large table with only a few rows where TB.COL3 = 4) SELECT * FROM TA JOIN TB ON TA.COL1 = TB.COL2 AND TB.COL3 = 4; SELECT * FROM TB JOIN TA ON TA.COL1 = TB.COL2 AND TB.COL3 = 4;(faster) 緣由是 TB.COL3 能夠被快速的估計,若是TB 表放到前面(index on TB.COL3): 通常規則是把縮小條件的列的表放在前面 3.4. 使用where 仍是join 使用 WHERE 條件連接表可能會下降運行速度. 下面的例子將會比較慢,即便使用了索引: SELECT ... FROM TA, TB, TC WHERE TC.COL3 = TA.COL1 AND TC.COL3=TB.COL2 AND TC.COL4 = 1 這個查詢隱含TA.COL1 = TB.COL2 ,可是沒有直接設定這個條件.若是 TA 和 TB 每一個表都包含100 條記錄,10000 組合將和 TC 關聯,用於TC這個列的條件,儘管有索引在這個列上.使用JOIN 關鍵字, 在組合TC 以前,TA.COL1 = TB.COL2 條件直接並縮小組合 TA 和 TB 的行數, 在運行大數據量的表的結果是,將會很快: SELECT ... FROM TA JOIN TB ON TA.COL1 = TB.COL2 JOIN TC ON TB.COL2 = TC.COL3 WHERE TC.COL4 = 1 這個查詢能夠提升一大步,若是改變表的順序, 因此 TC.COL1 = 1 將最早使用,這樣更小的集合將組合在一塊兒: SELECT ... FROM TC JOIN TB ON TC.COL3 = TB.COL2 JOIN TA ON TC.COL3 = TA.COL1 WHERE TC.COL4 = 1 以上例子,數據引擎自動應用於TC.COL4 = 1 組合小的集合於其它表關聯. Indexes TC.COL4, TB.COL2 TA.COL1 都將使用索引,提升查詢速度. 3.5. Subqueries and Joins 使用join 和調整表的順序提升效率. 例如:, 第二個查詢的速度將更快一些(TA.COL1 和TB.COL3都有索引): Example 2.2. Query comparison SELECT ... FROM TA WHERE TA.COL1 = (SELECT MAX(TB.COL2) FROM TB WHERE TB.COL3 = 4) SELECT ... FROM (SELECT MAX(TB.COL2) C1 FROM TB WHERE TB.COL3 = 4) T2 JOIN TA ON TA.COL1 = T2.C1 第二個查詢將 MAX(TB.COL2) 與一個單記錄表相關聯. 並使用TA.COL1索引,這將變得很是快. 第一個查詢是將 TA 表中的每一條記錄不斷地與MAX(TB.COL2)匹配. 3.6. 數據類型 TINYINT, SMALLINT, INTEGER, BIGINT, NUMERIC and DECIMAL (without a decimal point) are supported integral types and map to byte, short, int, long and BigDecimal in Java. Integral Types: TINYINT, SMALLINT, INTEGER, BIGINT, NUMERIC and DECIMAL Other Numeric Types: REAL, FLOAT or DOUBLE Bit and Boolean Types: BOOLEAN: UNDEFINED,TRUE,FALSE NULL values are treated as undefined. Storage and Handling of Java Objects Sequences and Identity Identity Auto-Increment Columns: The next IDENTITY value to be used can be set with the ALTER TABLE ALTER COLUMN <column name> RESTART WITH <new value>; Sequences: SELECT NEXT VALUE FOR mysequence, col1, col2 FROM mytable WHERE ... 3.7. 事務問題: SET PROPERTY "sql.tx_no_multi_rewrite" TRUE 4. Connections 通用驅動jdbc:hsqldb: 下列協議標識(mem: file: res: hsql: http: hsqls: https:) Table 4.1. Hsqldb URL Components Driver and Protocol Host and Port Database jdbc:hsqldb:mem: not available accounts jdbc:hsqldb:mem:. jdbc:hsqldb:file: not available mydb /opt/db/accounts C:/data/mydb 數據庫路徑. jdbc:hsqldb:res: not available /adirectory/dbname jars files are accessed in Java programs. The /adirectory above stands for a directory in one of the jars. jdbc:hsqldb:hsql: jdbc:hsqldb:hsqls: jdbc:hsqldb:http: jdbc:hsqldb:https: //localhost //192.0.0.10:9500 //dbserver.somedomain.com /an_alias /enrollments /quickdb 別名在server.properties or webserver.properties文件中指定 database.0=file:/opt/db/accounts dbname.0=an_alias database.1=file:/opt/db/mydb dbname.1=enrollments database.2=mem:adatabase dbname.2=quickdb In the example below, the database files lists.* in the /home/dbmaster/ directory are associated with the empty alias: database.3=/home/dbmaster/lists dbname.3= 4.1. Connection properties Connection properties are specified either by establishing the connection via the: DriverManager.getConnection (String url, Properties info); method call, or the property can be appended to the full Connection URL. Table 4.2. Connection Properties get_column_name true column name in ResultSet This property is used for compatibility with other JDBC driver implementations. When true (the default), ResultSet.getColumnName(int c) returns the underlying column name When false, the above method returns the same value as ResultSet.getColumnLabel(int column) Example below: jdbc:hsqldb:hsql://localhost/enrollments;get_column_name=false When a ResultSet is used inside a user-defined stored procedure, the default, true, is always used for this property. ifexists false connect only if database already exists Has an effect only with mem: and file: database. When true, will not create a new database if one does not already exist for the URL. When false (the default), a new mem: or file: database will be created if it does not exist. Setting the property to true is useful when troubleshooting as no database is created if the URL is malformed. Example below: jdbc:hsqldb:file:enrollments;ifexists=true shutdown false shut down the database when the last connection is closed This mimics the behaviour of 1.7.1 and older versions. When the last connection to a database is closed, the database is automatically shut down. The property takes effect only when the first connection is made to the database. This means the connection that opens the database. It has no effect if used with subsequent, simultaneous connections. This command has two uses. One is for test suites, where connections to the database are made from one JVM context, immediately followed by another context. The other use is for applications where it is not easy to configure the environment to shutdown the database. Examples reported by users include web application servers, where the closing of the last connection conisides with the web app being shut down. 4.2. Properties Files 大小寫敏感 (e.g. server.silent=FALSE will have no effect, but server.silent=false will work). 屬性文件和設定存儲以下 : Table 4.3. Hsqldb Server Properties Files File Name Location Function server.properties the directory where the command to run the Server class is issued settings for running HSQLDB as a database server communicating with the HSQL protocol webserver.properties the directory where the command to run the WebServer class is issued settings for running HSQLDB as a database server communicating with the HTTP protocol <dbname>.properties the directory where all the files for a database are located settings for each particular database Properties files for running the servers are not created automatically. You should create your own files that contain server.property=value pairs for each property. 4.2.1. Server and Web Server Properties server.properties and webserver.properties 文件支持以下設定: Table 4.4. Property File Properties Value Default Description server.database.0 test the path and file name of the first database file to use server.dbname.0 "" lowercase server alias for the first database file server.urlid.0 NONE SqlTool urlid used by UNIX init script. (This property is not used if your are running Server/Webserver on a platform other than UNIX, or of you are not using our UNIX init script). server.silent true no extensive messages displayed on console server.trace false JDBC trace messages displayed on console In 1.8.0, 每一個服務器支持同時啓動10個不一樣的數據庫. The server.database.0 property defines the filename / path whereas the server.dbname.0 defines the lowercase alias used by clients to connect to that database. The digit 0 is incremented for the second database and so on. Values for the server.database.{0-9} property can use the mem:, file: or res: prefixes and properties as discussed above under CONNECTIONS. For example, database.0=mem:temp;sql.enforce_strict_size=true; Values specific to server.properties are: Table 4.5. Server Property File Properties Value Default Description server.port 9001 TCP/IP port used for talking to clients. All databases are served on the same port. server.no_system_exit true no System.exit() call when the database is closed Values specific to webserver.properties are: Table 4.6. WebServer Property File Properties Value Default Description server.port 80 TCP/IP port used for talking to clients server.default_page index.html the default web page for server server.root ./ the location of served pages .<extension> ? multiple entries such as .html=text/html define the mime types of the static files served by the web server. See the source for WebServer.java for a list. All the above values can be specified on the command line to start the server by omitting the server. prefix. 5. SqlTool Mem 數據庫: E:\hsqldb>java -jar ./lib/hsqldb.jar mem Hsql Server: (前提是xdb server 已經啓動): (java -cp ../lib/hsqldb.jar org.hsqldb.Server -database.0 file:mydb -dbname.0 xdb) java -jar ./hsqldb.jar xdb 執行sql 語句: 1) Mydb.sql : CREATE MEMORY TABLE TEST(ID INTEGER,NAME VARCHAR(20)); INSERT INTO TEST VALUES(1,'aaa'); INSERT INTO TEST VALUES(2,'bbb'); E:\hsqldb>java -jar ./lib/hsqldb.jar mem mydb.sql 1 row updated 1 row updated 2) testuser.sql: CREATE MEMORY TABLE userTEST(ID INTEGER,NAME VARCHAR(20)); INSERT INTO userTEST VALUES(1,'aaa'); INSERT INTO userTEST VALUES(2,'bbb'); commit; //這樣才能提交到數據庫 E:\hsqldb>java -jar ./hsqldb.jar xdb testuser.sql > file.txt 2>&1 輸出結果到file.txt 文件中. 鏈接oracle: E:\hsqldb>java -classpath ./classes12.zip;./hsqldb.jar org.hsqldb.util.SqlTool --driver oracle.jdbc.driver.OracleDriver orcl sqltool.rc 文件: urlid orcl url jdbc:oracle:thin:@localhost:1521:livedoor username scott password tiger driver oracle.jdbc.OracleDriver 以上driver 在一處寫出便可,也能夠鏈接別的數據庫 鏈接mysql E:\hsqldb>java -classpath ./lib/mysql-connector-java-3.1.10-bin.jar;./hsqldb.jar org.hsqldb.util.SqlTool mysqltest .rc 文件內容: urlid mysqltest url jdbc:mysql://localhost:3306/test username root password root driver com.mysql.jdbc.Driver 6. sql 語法 6.1.1. ALTER INDEX[1] ALTER INDEX <indexname> RENAME TO <newname>; 6.1.2. ALTER SEQUENCE[1] ALTER SEQUENCE <sequencename> RESTART WITH <value>; 6.1.3. ALTER SCHEMA[1] ALTER SCHEMA <schemaname> RENAME TO <newname>; 6.1.4. ALTER TABLE[1] ALTER TABLE <tablename> ADD [COLUMN] <columnname> Datatype [(columnSize[,precision])] [{DEFAULT <defaultValue> | GENERATED BY DEFAULT AS IDENTITY (START WITH <n>[, INCREMENT BY <m>])}] | [[NOT] NULL] [IDENTITY] [PRIMARY KEY] [BEFORE <existingcolumn>]; ALTER TABLE <tablename> DROP [COLUMN] <columnname>; ALTER TABLE <tablename> ALTER COLUMN <columnname> RENAME TO <newname> ALTER TABLE <tablename> ALTER COLUMN <columnname> SET DEFAULT <defaultvalue>}; ALTER TABLE <tablename> ALTER COLUMN <columnname> SET [NOT] NULL ALTER TABLE <tablename> ALTER COLUMN <columnDefinition>; ALTER TABLE <tablename> ALTER COLUMN <columnname> RESTART WITH <new sequence value> ALTER TABLE <tablename> ADD [CONSTRAINT <constraintname>] CHECK (<search condition>); ALTER TABLE <tablename> ADD [CONSTRAINT <constraintname>] UNIQUE (<column list>); ALTER TABLE <tablename> ADD [CONSTRAINT <constraintname>] PRIMARY KEY (<column list>); ALTER TABLE <tablename> ADD [CONSTRAINT <constraintname>] FOREIGN KEY (<column list>) REFERENCES <exptablename> (<column list>) [ON {DELETE | UPDATE} {CASCADE | SET DEFAULT | SET NULL}]; ALTER TABLE <tablename> DROP CONSTRAINT <constraintname>; ALTER TABLE <tablename> RENAME TO <newname>; 6.1.5. ALTER USER[1] ALTER USER <username> SET PASSWORD <password>; ALTER USER <username> SET INITIAL SCHEMA <schemaname>; 6.1.6. CALL CALL Expression; See also: Stored Procedures / Functions, SQL Expression. 6.1.7. CHECKPOINT CHECKPOINT [DEFRAG[1]]; See also: SHUTDOWN, SET LOGSIZE. 6.1.8. COMMIT COMMIT [WORK]; See also: ROLLBACK, SET AUTOCOMMIT, SET LOGSIZE. 6.1.9. CONNECT CONNECT USER <username> PASSWORD <password>; See also: GRANT, REVOKE. 6.1.10. CREATE ALIAS CREATE ALIAS <function> FOR <javaFunction>; See also: CALL, Stored Procedures / Functions. 6.1.11. CREATE INDEX CREATE [UNIQUE] INDEX <index> ON <table> (<column> [DESC] [, ...]) [DESC]; 6.1.12. CREATE ROLE[1] CREATE ROLE <rolename>; 6.1.13. CREATE SCHEMA[1] CREATE SCHEMA <schemaname> AUTHORIZATION <grantee> [<createStatement> [<grantStatement>] [...]; CREATE SCHEMA ACCOUNTS AUTHORIZATION DBA CREATE TABLE AB(A INTEGER, ...) CREATE TABLE CD(C CHAHR, ...) CREATE VIEW VI AS SELECT ... GRANT SELECT TO PUBLIC ON AB GRANT SELECT TO JOE ON CD; 6.1.14. CREATE SEQUENCE[1] CREATE SEQUENCE <sequencename> [AS {INTEGER | BIGINT}] [START WITH <startvalue>] [INCREMENT BY <incrementvalue>]; SELECT [...,] NEXT VALUE FOR <sequencename> [, ...] FROM <tablename>; 6.1.15. CREATE TABLE CREATE [MEMORY | CACHED | [GLOBAL] TEMPORARY | TEMP [1] | TEXT[1]] TABLE <name> ( <columnDefinition> [, ...] [, <constraintDefinition>...] ) [ON COMMIT {DELETE | PRESERVE} ROWS]; 6.1.16. CREATE TRIGGER[1] CREATE TRIGGER <name> {BEFORE | AFTER} {INSERT | UPDATE | DELETE} ON <table> [FOR EACH ROW] [QUEUE n] [NOWAIT] CALL <TriggerClass>; 6.1.17. CREATE USER CREATE USER <username> PASSWORD <password> [ADMIN]; 6.1.18. CREATE VIEW[1] CREATE VIEW <viewname>[(<viewcolumn>,..) AS SELECT ... FROM ... [WHERE Expression] [ORDER BY orderExpression [, ...]] [LIMIT <limit> [OFFSET <offset>]]; CREATE VIEW mealsjv AS SELECT m.mid mid, m.name name, t.mealtype mt, a.aid aid, a.gname + ' ' + a.sname author, m.description description, m.asof asof FROM meals m, mealtypes t, authors a WHERE m.mealtype = t.mealtype AND m.aid = a.aid; CREATE VIEW mealswebv AS SELECT name, author FROM mealsjv; CREATE VIEW aview (new_name, new_author) AS SELECT name, author FROM mealsjv 6.1.19. DELETE DELETE FROM table [WHERE Expression]; 6.1.20. DISCONNECT DISCONNECT; 6.1.21. DROP INDEX DROP INDEX index [IF EXISTS]; 6.1.22. DROP ROLE[1] DROP ROLE <rolename>; 6.1.23. DROP SEQUENCE[1] DROP SEQUENCE <sequencename> [IF EXISTS] [RESTRICT | CASCADE]; 6.1.24. DROP SCHEMA[1] DROP SCHEMA <schemaname> [RESTRICT | CASCADE]; 6.1.25. DROP TABLE DROP TABLE <table> [IF EXISTS] [RESTRICT | CASCADE]; 6.1.26. DROP TRIGGER DROP TRIGGER <trigger>; 6.1.27. DROP USER DROP USER <username>; 6.1.28. DROP VIEW[1] DROP VIEW <viewname> [IF EXISTS] [RESTRICT | CASCADE]; 6.1.29. EXPLAIN PLAN EXPLAIN PLAN FOR { SELECT ... | DELETE ... | INSERT ... | UPDATE ..}; 6.1.30. GRANT GRANT { SELECT | DELETE | INSERT | UPDATE | ALL } [,...] ON { table | CLASS "package.class" } TO <grantee>; GRANT <rolename> [,...] TO <grantee>[1]; GRANT SELECT ON Test TO GUEST; GRANT ALL ON CLASS "java.lang.Math.abs" TO PUBLIC; 6.1.31. INSERT INSERT INTO table [( column [,...] )] { VALUES(Expression [,...]) | SelectStatement}; 6.1.32. REVOKE REVOKE { SELECT | DELETE | INSERT | UPDATE | ALL } [,...] ON { table | CLASS "package.class" } FROM <grantee>; REVOKE <rolename> [,...] FROM <grantee>[1]; 6.1.33. ROLLBACK ROLLBACK [TO SAVEPOINT <savepoint name>[1] | WORK}]; 6.1.34. SAVEPOINT[1] SAVEPOINT <savepoint name>; 6.1.35. SCRIPT SCRIPT ['file']; 6.1.36. SELECT[1] SELECT [{LIMIT <offset> <limit> | TOP <limit>}[1]][ALL | DISTINCT] { selectExpression | table.* | * } [, ...] [INTO [CACHED | TEMP | TEXT][1] newTable] FROM tableList [WHERE Expression] [GROUP BY Expression [, ...]] [HAVING Expression] [{ UNION [ALL | DISTINCT] | {MINUS [DISTINCT] | EXCEPT [DISTINCT] } | INTERSECT [DISTINCT] } selectStatement] [ORDER BY orderExpression [, ...]] [LIMIT <limit> [OFFSET <offset>]]; tableList table [{CROSS | INNER | LEFT OUTER | RIGHT OUTER} JOIN table ON Expression] [, ...] table { (selectStatement) [AS] label | tableName} selectExpression { Expression | COUNT(*) | { COUNT | MIN | MAX | SUM | AVG | SOME | EVERY | VAR_POP | VAR_SAMP | STDDEV_POP | STDDEV_SAMP } ([ALL | DISTINCT][1]] Expression) } [[AS] label] If CROSS JOIN is specified no ON expression is allowed for the join. orderExpression { columnNr | columnAlias | selectExpression } [ASC | DESC] LIMIT n m LIMIT n m LIMIT m OFFSET n TOP m UNION and other set operations 6.1.37. SET AUTOCOMMIT SET AUTOCOMMIT { TRUE | FALSE }; 6.1.38. SET DATABASE COLLATION[1] SET DATABASE COLLATION <double quoted collation name>; 6.1.39. SET CHECKPOINT DEFRAG[1] SET CHECKPOINT DEFRAG <size>; 6.1.40. SET IGNORECASE SET IGNORECASE { TRUE | FALSE }; 6.1.41. SET INITIAL SCHEMA [1] Users may change their base default schema name with the comand SET INITIAL SCHEMA <schemaname>; 6.1.42. SET LOGSIZE SET LOGSIZE <size>; 6.1.43. SET PASSWORD SET PASSWORD <password>; 6.1.44. SET PROPERTY[1] SET PROPERTY <double quoted name> <value>; 6.1.45. SET REFERENTIAL INTEGRITY SET REFERENTIAL_INTEGRITY { TRUE | FALSE }; 6.1.46. SET SCHEMA[1] SET SCHEMA <schemaname>; 6.1.47. SET SCRIPTFORMAT[1] SET SCRIPTFORMAT {TEXT | BINARY | COMPRESSED}; 6.1.48. SET TABLE INDEX SET TABLE tableName INDEX 'index1rootPos index2rootPos ... '; 6.1.49. SET TABLE READONLY[1] SET TABLE <tablename> READONLY {TRUE | FALSE}; 6.1.50. SET TABLE SOURCE[1] SET TABLE <tablename> SOURCE <file and options> [DESC]; SET TABLE mytable SOURCE "myfile;fs=|;vs=.;lvs=~" Supported Properties quoted = { true | false } default is true. If false, treats double quotes as normal characters all_quoted = { true | false } default is false. If true, adds double quotes around all fields. encoding = <encoding name> character encoding for text and character fields, for example, encoding=UTF-8 ignore_first = { true | false } default is false. If true ignores the first line of the file cache_scale= <numeric value> exponent to calculate rows of the text file in cache. Default is 8, equivalent to nearly 800 rows cache_size_scale = <numeric value>r exponent to calculate average size of each row in cache. Default is 8, equivalent to 256 bytes per row. fs = <unquoted character> field separator vs = <unquoted character> varchar separator lvs = <unquoted character> long varchar separator Special indicators for Hsqldb Text Table separators \semi semicolon \quote quote \space space character \apos apostrophe \n newline - Used as an end anchor (like $ in regular expressions) \r carriage return \t tab \\ backslash \u#### a Unicode character specified in hexadecimal Only an administrator may do this. 6.1.51. SET WRITE DELAY[1] SET WRITE_DELAY {{ TRUE | FALSE } | <seconds> | <milliseconds> MILLIS}; 6.1.52. SHUTDOWN SHUTDOWN [IMMEDIATELY | COMPACT | SCRIPT[1]]; 6.2. Data Types Table 9.1. Data Types. The types on the same line are equivalent. Name Range Java Type INTEGER | INT as Java type int | java.lang.Integer DOUBLE [PRECISION] | FLOAT as Java type double | java.lang.Double VARCHAR as Integer.MAXVALUE java.lang.String VARCHAR_IGNORECASE as Integer.MAXVALUE java.lang.String CHAR | CHARACTER as Integer.MAXVALUE java.lang.String LONGVARCHAR as Integer.MAXVALUE java.lang.String DATE as Java type java.sql.Date TIME as Java type java.sql.Time TIMESTAMP | DATETIME as Java type java.sql.Timestamp DECIMAL No limit java.math.BigDecimal NUMERIC No limit java.math.BigDecimal BOOLEAN | BIT as Java type boolean | java.lang.Boolean TINYINT as Java type byte | java.lang.Byte SMALLINT as Java type short | java.lang.Short BIGINT as Java type long | java.lang.Long REAL as Java type double | java.lang.Double[1] BINARY as Integer.MAXVALUE byte[] VARBINARY as Integer.MAXVALUE byte[] LONGVARBINARY as Integer.MAXVALUE byte[] OTHER | OBJECT as Integer.MAXVALUE java.lang.Object The uppercase names are the data types names defined by the SQL standard or commonly used by RDMS's. The data types in quotes are the Ja 6.2.1. 自動增加: create table user(id IDENTITY,name varchar(20)); sql> create table dept(id int GENERATED BY DEFAULT AS IDENTITY(start with 10,increment by 5) not null PRIMARY KEY,name v archar(20)); sql> insert into dept(name) values('asc'); 1 row updated sql> insert into dept(name) values('security'); 1 row updated sql> select * from dept; ID NAME -- -------- 10 asc 15 security 2 rows 6.3. SQL Comments -- SQL style line comment // Java style line comment /* C style line comment */ 7. Hsqldb Test Utility 拷貝 junit.jar 到/lib 目錄下 運行: ant hsqldbtest 生成 hsqldbtest.jar 運行: \hsqldb\testrun\hsqldb>runtest TestSelf