Latest Stable
2.7.4
Released 03 Nov 2024
(1 year ago)
Software
HyperSQL DB
IntroductionHyperSQL DB (HSQLDB) is a lightweight, open-source relational database engine written in Java. It supports in-memory and file-based databases, full SQL standards, and offers high performance with zero configuration. Perfect for embedded applications, unit/integration testing, prototyping, and small to medium production systems.
Written inJava
Operating systemCross-platform
Repositoryhttps://svn.code.sf.net/p/hsqldb/svn/
Websitehttps://hsqldb.org
LicenseBSD license
LATEST RELEASES:
2.7.4 03 Nov 2024 (1 year ago)
2.7.3 31 May 2024 (2 years ago)
2.7.2 31 May 2023 (3 years ago)
2.7.1 22 Oct 2022 (3 years ago)
2.7.0 26 Jul 2022 (3 years ago)

All Releases

VersionSupported
Java versions
Initial releaseLatest release
2.7JRE 11
JRE 8: alternative jar
2.7.0
26 Jul 2022
(3 years ago)
2.7.4
03 Nov 2024
(1 year ago)
2.6JRE 11
JRE 8: alternative jar
2.6.0
08 Apr 2021
(5 years ago)
2.6.1
25 Oct 2021
(4 years ago)
2.5JRE 82.5.0
03 Jun 2019
(6 years ago)
2.5.2
12 Apr 2021
(5 years ago)
2.4JRE 82.4.0
09 Apr 2017
(9 years ago)
2.4.1
20 May 2018
(8 years ago)
2.3JRE 62.3.0
18 Jul 2013
(12 years ago)
2.3.6
20 May 2018
(8 years ago)
2.2JRE 62.2.4
13 Jun 2011
(14 years ago)
2.2.9
12 Oct 2012
(13 years ago)
2.0JRE 62.0.0
11 Jun 2010
(15 years ago)
2.0.0
11 Jun 2010
(15 years ago)

How Is HyperSQL Maintained and Who Supports It?

HSQLDB does not follow a versioned support lifecycle with published EOL dates. It is maintained by the HSQL Development Group -- a small, tight-knit team coordinated by a full-time maintainer -- and operates as a community-driven open source project under the BSD license. Only the current major line (2.x) receives active development; the 1.8.x line has been frozen for many years with no further updates.

Support is provided through community forums and the SourceForge tracker. There is no commercial SLA or guaranteed response time for the general public. The project does offer SupportWare -- an annual subscription program that funds ongoing development and grants subscribers priority on support requests and feature submissions. Teams embedding HSQLDB in commercial applications are encouraged to participate.

Version Line Java Requirement Status Notes
2.7.x (current) JRE 11+ (JRE 8 via alternate jar) Actively maintained All new features, SQL:2023 support
2.6.x JRE 11+ (JRE 8 via alternate jar) No active development Last patch released, no further updates expected
2.5.x and below JRE 8 Frozen No bug fixes or security patches
1.8.x JRE 1.1+ Abandoned Legacy line, do not use in new projects

For current release status and documentation, refer to the official HyperSQL website and the HyperSQL User Guide.

What Are the Real Risks of Running an Outdated HSQLDB Version?

The risk profile for HSQLDB depends heavily on how you are using it. Most applications use HSQLDB as an embedded in-memory database for testing -- in that scenario, an old version is mostly an inconvenience. But for teams using HSQLDB with disk-based persistence (file: or res: catalog modes), or as a lightweight embedded production store, the stakes are considerably higher.

Risks specific to disk-based and production usage

Risk Area Description
Database file format compatibility HSQLDB file formats can change between minor versions. Upgrading a version while a .script or .data file is already on disk requires careful migration -- older files may not load cleanly into a newer engine without a manual export/import cycle
JDBC and SQL standard drift Older versions implement earlier SQL standards. Queries relying on SQL:2008 or SQL:2016 behavior -- temporal tables, MVCC semantics, advanced aggregate functions -- may fail or produce incorrect results on older engines
Java version incompatibility Versions below 2.6 were not compiled as Java module jars and do not support the Java 9+ module system. Running them on modern JVMs can surface illegal reflective access warnings or outright failures depending on JVM configuration
Unpatched engine bugs Crash recovery, transaction isolation, and LOB storage bugs reported after a version's last patch release are never backported. With a single full-time maintainer, older branches receive no attention once the focus shifts to the current line
Testing vs production divergence Running a different HSQLDB version in tests than in the embedded production store is a common mistake -- SQL dialect differences and type coercion behavior can cause tests to pass while production queries silently return wrong results

What Happens When an HSQLDB Version Is No Longer Updated?

Unlike larger database vendors, HSQLDB does not announce deprecation windows or end-of-life transitions. A version simply stops receiving patches when the maintainer's focus moves on. There is no announcement, no migration deadline, and no LTS commercial option. The last published jar for that minor line is what you get, indefinitely.

For in-memory test usage, this is largely fine -- the JAR keeps working until a Java version upgrade breaks compatibility. In practice, the most common breaking point is a JRE major version upgrade: if your CI pipeline moves from Java 11 to Java 21, an old HSQLDB jar compiled without module support may begin emitting warnings or failing under strict module enforcement.

For disk-based usage, the situation is different. HSQLDB catalog files are tied to the engine version that created them. If you need to upgrade the engine to maintain Java compatibility, you must first export your data using the old engine and re-import using the new one. Skipping versions significantly increases the complexity of this migration, especially if the schema uses features that changed behavior between releases.

Usage Pattern Impact of Outdated Version Urgency to Upgrade
In-memory testing only (mem:) Low -- no persistent state, no file format risk Low -- upgrade when Java version forces it
File-based embedded store (file:) Medium -- engine bugs go unpatched, file format risk on upgrade Medium -- keep within one minor line of current
Server mode (standalone process) High -- exposed network surface, no security patches on old versions High -- stay on the current 2.7.x line

How Do You Check Your HSQLDB Version?

There are several ways to confirm the exact HSQLDB version in use, depending on your build tool and deployment mode.

Check via Maven

mvn dependency:tree | grep hsqldb

Look for both hsqldb and any transitive dependencies pulling in an older version from a framework like Spring Boot or Liquibase:

[INFO] +- org.hsqldb:hsqldb:jar:2.7.4:test

Check via Gradle

./gradlew dependencies --configuration testRuntimeClasspath | grep hsqldb

Check at runtime via JDBC

From a JDBC connection, you can query the engine version directly using standard SQL:

SELECT * FROM INFORMATION_SCHEMA.SYSTEM_SESSIONINFO
WHERE KEY = 'DATABASE VERSION';

Or using the DatabaseMetaData API:

DatabaseMetaData meta = connection.getMetaData();
System.out.println(meta.getDatabaseProductVersion());
// e.g. "2.7.4"

Check the JAR manifest directly

If you have the JAR on disk and want to verify its version without running it:

unzip -p hsqldb.jar META-INF/MANIFEST.MF | grep Implementation-Version

Note that if HSQLDB is pulled in transitively by Spring Boot, Hibernate, or another framework, the version in your test classpath may not be the one you specified -- always verify with dependency:tree to confirm no conflict is resolving to an unexpected version.

FAQ

Q1: Does HSQLDB have an official end-of-life date for older versions?
No. The HSQL Development Group does not publish EOL dates or deprecation timelines. Older minor versions simply stop receiving patches once the maintainer's focus shifts to the current line. The only reliable indicator of active development is whether a version line has received a new release recently -- as shown in the release table above. If a minor version has had no new patch for an extended period, treat it as effectively frozen regardless of any official statement.

Q2: Is it safe to use HSQLDB in production, or is it only for testing?
HSQLDB is fully capable of production use, particularly in embedded scenarios where a lightweight, zero-configuration Java database is needed. It supports ACID transactions, MVCC, disk persistence, server mode, and connection pooling. That said, most teams use it specifically for in-memory test databases and reach for PostgreSQL or MySQL when production requirements grow. The key limitation is its single-maintainer structure -- there is no enterprise support tier, no security advisory process, and no guaranteed patch cadence for production-critical vulnerabilities.

Q3: What is the difference between HSQLDB mem:, file:, and res: catalog types?
mem: databases exist entirely in JVM memory and are destroyed when the JVM exits -- ideal for isolated unit tests. file: databases persist to disk using a set of files (.script, .log, .data, .properties, .backup) -- suitable for embedded production use where data must survive restarts. res: databases are read-only catalogs loaded from the classpath, typically embedded inside JARs -- useful for distributing static reference data with an application. Mixing catalog types in the same application is supported; each connection URL specifies its own catalog type independently.

Q4: Can I upgrade HSQLDB in place without migrating my database files?
It depends on how far you are upgrading. Patch releases within the same minor line (e.g. 2.7.1 to 2.7.4) are generally safe for in-place upgrades. Upgrading across minor versions (e.g. 2.5.x to 2.7.x) carries more risk -- the internal file format and SQL dialect may have changed. The safest approach for disk-based catalogs is to use SCRIPT to export a full SQL dump with the old engine, then re-create the catalog with the new engine by replaying the script. Always back up all catalog files before any engine upgrade.

Q5: Why does my Spring Boot test use a different HSQLDB version than what I declared in my pom.xml?
Spring Boot's dependency management BOM includes a managed version of HSQLDB. If you declare a dependency without an explicit version, Maven resolves it from the BOM. If you declare a version explicitly but Spring Boot's BOM specifies a different one, the BOM typically wins in the effective dependency resolution unless you override it intentionally. Run mvn dependency:tree | grep hsqldb to see which version is actually on your classpath and trace where it is coming from. To pin a specific version, declare it inside your <dependencyManagement> section to ensure it takes precedence over the BOM.