HSQLDB数据库使用详解(入门)及快速使用

清疚 2022-05-16 11:50 1215阅读 0赞

# [hsql数据库使用详解(入门)及快速使用][hsql] #

一、简介：

hsql数据库是一款纯Java编写的免费数据库，许可是BSD-style的协议，如果你是使用Java编程的话，不凡考虑一下使用它，相对其

他数据库来说，其体积小，才563kb。仅一个hsqldb.jar文件就包括了数据库引擎，数据库驱动， 还有其他用户界面操作等内容。在

Java开源世界里，hsql是极为受欢迎的（就Java本身来说），JBoss应用程序服务器默认也提供了这个数据库引 擎。由于其体积小的

原因，又是纯Java设计，又支持SQL99，SQL2003大部分的标准，所以也是作为商业应用程序展示的一种选择。请到以下地址下载hsql

： http://prdownloads.sourceforge.net/hsqldb/hsqldb\_1\_7\_3\_3.zip?download

二、使用hsql数据库：

1、hsql数据库引擎有几种服务器模式：常用的Server模式、WebServer模式、Servlet模式、Standlone模式、Memory-Only数据库。

2、最为常用的Server模式：

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包里的手册。

3、WebServer模式和Server运行模式基本一样，只是支持了Http等协议，主要用于防火墙，默认端口是9001。启动Server，java -cp hsqldb.jar org.hsqldb.WebServer ...剩余的和上面的一致。

4、Servlet模式可以允许你通过Servlet容器来访问数据库，请查看hsqlServlet.java的源代码，和WebServer类似。

5、另一个值得思考的模式是Standalone模式：不能通过网络来访问数据库，主要是在一个JVM中使用，那样的话，访问的速度会更加快。虽然文档里面提到主要是用于开发时使用，但是我们可以假设一下，该方法不需要一个引擎类的东西，而类似于打开文件的方式，返回一个Connection对象：

Connection c = DriverManager.getConnection("jdbc:hsqldb:file:mydb", "sa", "");

将 会在当前目录找到mydb数据库相关文件，打开并返回一个Connection对象。该方式有点好处就是可以不使用引擎，在需要的时候操作数据。所以那些 对数据库不是特别有要求的，但又需要一个操作数据库的方式的话，可以使用这种方法。对于那些不想额外在数据库引擎花费金钱的话，可以使用这种方法。但是不 推荐使用该方法。记得Hibernate里SessionFactory可以使用openSession(Connecttion c)来获得一个Session对象的，因此，在测试或者实际应用的话都可以这样使用。

6、Memory-Only 数据库：顾名思义，主要是内存中使用，不用于保存数据。可以用于在内存中交换数据。

三、具体的链接与操作的话，和一般的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 安装与使用][HSQLDB] #

HSQLDB是一个轻量级的纯Java开发的开放源代码的关系数据库系统，其体积小，占用空间小，使用简单，支持内存运行方式等特点。可以在

[http://sourceforge.net/projects/hsqldb/files/][http_sourceforge.net_projects_hsqldb_files]

下载最新的HSQLDB版本。我这里下载的是 **HSQLDB 2.2.7** 版本。下载完之后，把它解压到任一目录下，如 **E:\\hsqldb** 下，完成安装工作。

**Hsqldb有四种运行模式**：

一、**内存（Memory-Only）模式**：所有的数据都将在内存中完成，如果程序退出，则相应的数据也将同时被销毁。连接JDBC的实例为：**jdbc:hsqldb:mem:dbname**

二、**进行（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

三、**服务器模式**：此模式下 **HSQLDB **跟其它数据库服务器一样，需要通过服务器的形式来进行启动，可以通过

java -classpath ../lib/hsqldb.jar org.hsqldb.server.WebServer –database.0 testdb –dbname.0 testdbName

的命令启动一个守护进程。连接 **JDBC **的实例为：

jdbc:hsqldb:hsql://localhost:port/dbname

四、**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 **数据库。

![2012012023195411.jpg][]

此时，在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 文件，并双击文件，此时回弹出图形界面（注意，在进行这一不之前，必须确保第二步已执行），如下图。

![2012012023212886.jpg][]

**Recent**：将会列出最近的数据库配置

**Setting Name:** 设置名称，这里不需要填写

**Type：**选择服务器模式**（HSQL Database Engine Server）**

**Driver：**驱动名称，不需要修改

**URL：**JDBC连接，无需修改

**User：**用户名,根据需要设置

**Password：**密码，根据需要设置

5．点击【OK】按钮，即可连接到 **test **数据库。如下图所示。

![2012012023223064.jpg][]

此时，我们可以在窗口中创建表等操作，例如，我们创建一个TBL\_USERS的表。在菜单栏中选择 **COMMAND ->** **CREATE TABLE**命令，此时在右下文本框中显示创建表的命令，包括各式，支持的类型等。我们创建的 **TBL\_USERS **表结构如下图所示：

![复制代码][copycode.gif]

CREATE TABLE TBL_USERS(
             ID INTEGER NOT NULL PRIMARY KEY,
             FIRST_NAME VARCHAR(20),
             LAST_NAME VARCHAR (30),
             LOGIN_DATE DATE
     )

![复制代码][copycode.gif]

![2012012023231719.jpg][]

6．点击【Execute】按钮，如果无语法错误，SQL语句将正常执行，此时，选择菜单栏中的 **View -> Refresh Tree** 命令，左侧栏中将显示创建的 **TBL\_USERS **。如下图所示。并且查看 test.log 文件，创建表的过程都将全部记录。

![2012012023234528.jpg][]

7．另外还可以用 **DatabaseManagerSwing **工具启动图形界面。创建 runManagerSwing.bat 文件，内容为：

cd ..\data
    @java -classpath ..\lib\hsqldb.jar org.hsqldb.util.DatabaseManagerSwing

保存文件，双击该文件，将启动 **Swing **图形界面，如下图所示，具体的操作过程和 **DatabaseManager **工具类似，不再重复。

![2012012023244145.jpg][]

以上就是启动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 **数据库中，如下图所示：

![2012012023253945.jpg][]

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 文件，内容如下：

![复制代码][copycode.gif]

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;
            }
        }   
    }

![复制代码][copycode.gif]

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 **数据库的连接   
  
使用例：

![复制代码][copycode.gif]

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");

![复制代码][copycode.gif]

其中，jdbc:hsqldb:hsql://localhost/xdb 需要替换为合适的 **jdbc-url **。   
有关**JDBC-URL**的详细描述请参考**HSQLDB**的四种运行模式   
  
在Hibernate里使用HSQLDB   
著名的ORM工具Hibernate也提供了对 **HSQLDB **数据库的支持。需要在Hibernage里使用 **HSQLDB **，只需在 hibernate.cfg.xml 里加入类似如下设置：

![复制代码][copycode.gif]

<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>

![复制代码][copycode.gif]

其余就跟其他数据库的用法一样了，这里不再详述。

### HSQLDB创建数据库和基本的数据库访问   ###

一、     简介

Hsqldb是一个纯java编写的轻量级数据库，主要有三种运行模式：

1．Server模式

2．Standlone模式

3．Memory-Only模式

其中server模式又分为：

1．Hsqldb Server模式

2．Hsqldb Web Server模式

3．Hsqldb Servlet模式

二、     官网和最新版本

访问Hsqldb的官方地址：[http://hsqldb.org/][http_hsqldb.org]，下载最新的hsqldb，下载地址：

http://nchc.dl.sourceforge.net/project/hsqldb/hsqldb/hsqldb\_2\_1/hsqldb-2.1.0.zip，我下载时的最新版本是2.1.0。下载后解压。

三、     使用HSQL数据库

下面介绍一下如何创建数据库：

1.    创建文件夹

在E盘下建立一个目录hsqldb文件夹（这个是任意建立的，呵呵），将hsqldb.jar拷贝到里面，然后再里边再建立一个data的文件夹（当然这个文件夹也是任意建立的，起其他名字也可以）如下图所示：

![HSQLDB创建数据库和基本的数据库访问 - jiaxiaoyuan1204 - 武陵源的传奇][HSQLDB_ - jiaxiaoyuan1204 -]

图0

2.    创建数据库

进入命令提示符，进入data文件夹，输入命令：

E:\\hsqldb\\data>java -cp ../hsqldb.jar org.hsqldb.Server -database mydb

这时候，data文件夹中就会出现两个文件：mydb.log 和 mydb.properties ，也就是创建了一个名称为mydb的数据库，如下图所示。注意，这也是数据库引擎的启动界面，如果将其关闭，第三步不能成功，因为数据库启动引擎关闭了，特别要注意，呵呵。

![HSQLDB创建数据库和基本的数据库访问 - jiaxiaoyuan1204 - 武陵源的传奇][HSQLDB_ - jiaxiaoyuan1204 - 1]

图1

生成的数据库文件如下图所示：

![HSQLDB创建数据库和基本的数据库访问 - jiaxiaoyuan1204 - 武陵源的传奇][HSQLDB_ - jiaxiaoyuan1204 - 2]

图2

3.    客户端工具

另外打开一个CMD终端，进入到E:\\hsqldb\\data目录，输入命令：java -cp ../hsqldb.jar org.hsqldb.util.DatabaseManager （注：还是在data目录执行这个命令），就会出现一个数据库控制界面，如图：（这里选择的是In-Memory模式，当然Server模式也可以）

![HSQLDB创建数据库和基本的数据库访问 - jiaxiaoyuan1204 - 武陵源的传奇][HSQLDB_ - jiaxiaoyuan1204 - 3]

图3

![HSQLDB创建数据库和基本的数据库访问 - jiaxiaoyuan1204 - 武陵源的传奇][HSQLDB_ - jiaxiaoyuan1204 - 4]

图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;

就可以查询出这条数据了，如下图所示：

![HSQLDB创建数据库和基本的数据库访问 - jiaxiaoyuan1204 - 武陵源的传奇][HSQLDB_ - jiaxiaoyuan1204 - 5]

图5

如果现在我们把数据库运行引擎关闭，即关闭图1中所示的运行引擎。如果再次运行引擎，即：java -cp ../hsqldb.jar org.hsqldb.Server -database mydb ，就会在data文件夹中出现一个文件mydb.srcipt，这里面保存着数据执行文件，运行时会执行这个文件中sql语句。也就是说，数据以sql的形式保存在mydb.srcipt文件里面，再次运行引擎时，会再次插入这些保存的数据，这样会看到上次咱们建立的customer的数据表，如下图示：

![HSQLDB创建数据库和基本的数据库访问 - jiaxiaoyuan1204 - 武陵源的传奇][HSQLDB_ - jiaxiaoyuan1204 - 6]

图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

[hsql]: https://www.cnblogs.com/zdxster/p/5345194.html
[HSQLDB]: http://www.cnblogs.com/saintaxl/archive/2012/01/20/2328356.html
[http_sourceforge.net_projects_hsqldb_files]: http://sourceforge.net/projects/hsqldb/files/
[2012012023195411.jpg]: /images/20220516/80741e121c914b9ca68064f5a92ac69d.png
[2012012023212886.jpg]: /images/20220516/1d04509b2919495bac35636d4c9dde25.png
[2012012023223064.jpg]: /images/20220516/a3516fa6d1204795ac07ce5885fde644.png
[copycode.gif]: /images/20220516/06b7d10b7e8f421ba6c88200243d22b2.png
[2012012023231719.jpg]: /images/20220516/2ca6fdd14e3e468088e3de471aef4274.png
[2012012023234528.jpg]: /images/20220516/5ed5ef78719441c486d65ae0d257ab95.png
[2012012023244145.jpg]: /images/20220516/fa1b01c778d946a4b30536196ee2ce33.png
[2012012023253945.jpg]: /images/20220516/0be94d009cbb4b62a4dc4e8c2c15cec7.png
[http_hsqldb.org]: http://hsqldb.org/
[HSQLDB_ - jiaxiaoyuan1204 -]: http://img465.ph.126.net/IRObXDLZASaDnavFW5EedA==/1557682521117994109.jpg
[HSQLDB_ - jiaxiaoyuan1204 - 1]: http://img153.ph.126.net/oTLiD8iXm3IgVjMS_pKAWA==/1650006313479810064.jpg
[HSQLDB_ - jiaxiaoyuan1204 - 2]: http://img306.ph.126.net/eAmtxtRYudEAQckbDLXR5w==/3850014731448959506.jpg
[HSQLDB_ - jiaxiaoyuan1204 - 3]: http://img612.ph.126.net/PoORbQqN0bZm0jR2KvdUlg==/1698420009473844032.jpg
[HSQLDB_ - jiaxiaoyuan1204 - 4]: http://img66.ph.126.net/qmB9Ae1VSFTf3KjP55-S3A==/840484280459833653.jpg
[HSQLDB_ - jiaxiaoyuan1204 - 5]: http://img242.ph.126.net/nOghsRFgRzDk-DVdhKVn9Q==/2137520973142743291.jpg
[HSQLDB_ - jiaxiaoyuan1204 - 6]: http://img234.ph.126.net/Qrr76wzt63LaimiP-p8TGQ==/1404560133788136412.jpg