<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html><head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8"><title>HSQLDB</title></head>
<body>
<img style="width: 223px; height: 47px;" alt="HyperSQL logo" src="doc-src/images/hypersql_logo.png">
<h3><br>
</h3>
<h3>HyperSQL version 2.0.0 Distribution</h3>
<p>HSQLDB (HyperSQL DataBase) is a relational
database engine written in Java. Version 2.0 is the result of nearly
5 years
development since the last major version. It offers many features and
adheres
closely to the latest SQL and JDBC 4 standards.</p>
<p>This
is the first GA Release for version 2.0.</p>
<h4>SUPPORTWARE</h4>
The development and maintenance of&nbsp; HyperSQL has been possible
because of financial contributions by business users. We need renewed
contributions. Please subscribe to SupporWare at&nbsp; <a href="http://hsqldb.org/web/supportware">http://hsqldb.org/web/supportware</a>
.
<h4>PACKAGE CONTENTS</h4>
<p>This download contains the
following files and directories: </p>
<p><b>bin</b></p>
<p>This directory contains some
Windows utility wrapper scripts, and some HTML pages with HSQLDB
embedded as an
applet.</p>
<h4>build</h4>
<p>This directory contains the ant
build.xml script plus MSDOS CMD files for build. See the <a href="doc/guide/building-app.html">Building HyperSQL Jars</a>
appendix of the
HyperSQL User Guide for details. </p>
<h4>classes</h4>
<p>When the jar is rebuilt, this
directory contains the *.class files generated by the ANT build tool.
It does
not exist in the distribution zip.</p>
<h4>doc</h4>
<p>A set of HTML, PDF and text
documents covering different aspects of HSQLDB and some of its
utilities.</p>
<p><a href="doc/guide/index.html">HyperSQL
User Guide</a> in HTML format. <br>
<a href="doc/guide/guide.pdf">HyperSQL User Guide</a>
in PDF format. </p>
<p><a href="doc/util-guide/index.html">HyperSQL
Utilities Guide</a> in HTML format.<br>
<a href="doc/util-guide/util-guide.html">HyperSQL
Utilities Guide</a> in PDF
format. </p>
<p>The <a href="doc/apidocs/index.html">JavaDoc</a>
for public classes, including the JDBC documentation. </p>
<p>(in future) Chronological list of
minor changes and bug fixes since the release of version 2.0.0 <a href="doc/changelist_2_0_0.txt">changelist_2_0_0.txt</a>
</p>
<p>The license texts for the source and binaries, based on the
BSD license. <a href="doc/hsqldb_lic.txt">hsqldb_lic.txt</a>
is for sources developed entirely by the HSQL Development Group. <a href="doc/hypersonic_lic.txt">hypersonic_lic.txt</a>
is for sources that contain code from the closed HypersonicSQL project.</p>
<h4>lib</h4>
<p>The jar needed for running HyperSQL
and its GUI utilities (hsqldb.jar) has been pre-built in this
directory. The jar is
compatible with Java version 1.6. The jar for SqlTool (sqltool.jar) is
also in this directory. The extra zip file in the directory is needed
only for
recompiling hsqldb and is not required for deployment. </p>
<h4>src</h4>
<p>All source code is in this
directory. </p>
<h4>testrun</h4>
<p>Contains test scripts for the
database engine and SqlTool. These scripts are run by separate test
utilities
for the engine and SqlTool</p>
<h4>CHANGES</h4>
<ul>
<li>There are very many new features in the new version. Most
of these do not affect existing features in version 1.8.x.</li>
<li>For use with existing applications, the main differences
are as follows:</li>
<li>Transaction isolation is always enforced - READ COMMITTED
and SERIALIZABLE modes are supported.</li>
<li>GENERATE BY DEFAULT AS IDENTITY does not create a primary
key. A primary key must be declared explicitly.</li>
<li>Column sizes are enforced, although you can change this and
other properties to some extent.</li>
</ul>
<h4>UPDATES</h4>
We constantly fix reported issues. Please check the web site regularly
for&nbsp;latest updated version and latest information.
<h4>SUPPORT</h4>
<p>Support for HyperSQL is available
from <a href="http://hsqldb.org/support">http://hsqldb.org/support</a>
in
various forms, including a mailing list and user forums. The web site
features
the latest bugfix versions of the software, FAQ and other useful
resources.</p>
<p>Fred Toussi (fredt (at)
users.sourceforge.net)<br>
Blaine Simpson (blaine dot simpson (at) admc dot com)</p>
<p><a href="http://hsqldb.org">http://hsqldb.org</a>&nbsp;</p>
</body></html>
