Roadmap

Highest Priority

Improve test code coverage
More fuzz tests
Test very large databases and LOBs (up to 256 GB)
Test multi-threaded in-memory db access

In Version 1.1

Add version number. Install directory: h2-1.0, jar file: h2-1.0.jar. Micro version: use build number, staring with 1.1.100
Automatic upgrade if there is a file format change
Change Constants.DEFAULT_MAX_MEMORY_UNDO to 10000 (and change the docs). Test.
Enable and document optimizations, LOB files in directories
Special methods for DataPage.writeByte / writeShort and so on
Index organized tables CREATE TABLE...(...) ORGANIZATION INDEX (store in data file) (probably file format changes are required for rowId)
Change the default for NULL || 'x' to NULL

Priority 1

Write more tests and documentation for MVCC (Multi Version Concurrency Control)
RECOVER=1 should automatically recover, =2 should run the recovery tool if required
More tests with MULTI_THREADED=1
Test with Spatial DB in a box / JTS (http://docs.codehaus.org/display/GEOS/SpatialDBBox)
Optimization: result set caching (like MySQL)
Server side cursors
Row level locking
Long running queries / errors / trace system table
Migrate database tool (also from other database engines)
Shutdown compact
Document server mode, embedded mode, web app mode, dual mode (server+embedded)
Updatable result sets: DatabaseMetaData.ownUpdatesAreVisible = true (for insert, delete, update) Simple solution: automatically calls 'refresh' when the result was changed. Compare with other databases.

Priority 2

Automatic mode: jdbc:h2:auto: (embedded mode if possible, if not use server mode). Keep the server running until all have disconnected.
Support OSGi: http://oscar-osgi.sourceforge.net, http://incubator.apache.org/felix/index.html
Better space re-use in the files after deleting data (shrink the files)
Shrink the data file without closing the database (if the end of the file is empty)
ParameterMetaData should return correct data type where possible (INSERT, UPDATE; supported by PostgreSQL, Derby, HSQLDB)
Pluggable tracing system
Full outer joins
Procedural language / script language (Javascript)
Change LOB mechanism (less files, keep index of lob files, point to files and row, delete unused files earlier, maybe bundle files into a tar file)
Clustering: recovery needs to becomes fully automatic. Global write lock feature.
Option for Java functions: constant/isDeterministic to allow early evaluation when all parameters are constant
Deferred integrity checking (DEFERRABLE INITIALLY DEFERRED)
Groovy Stored Procedures (http://groovy.codehaus.org/Groovy+SQL)
System table / function: cache usage
Add a migration guide (list differences between databases)
Optimization: automatic index creation suggestion using the trace file?
Compression performance: don't allocate buffers, compress / expand in to out buffer
Connection pool manager
Implement Statement.cancel for server connections
Start / stop server with database URL
Sequence: add features [NO] MINVALUE, MAXVALUE, CYCLE
Rebuild index functionality (other than delete the index file)
Don't use deleteOnExit (bug 4513817: File.deleteOnExit consumes memory)
Console: add accesskey to most important commands (A, AREA, BUTTON, INPUT, LABEL, LEGEND, TEXTAREA)
Feature: a setting to delete the the log or not (for backup)
Test with Sun ASPE1_4; JEE Sun AS PE1.4
Test performance again with SQL Server, Oracle, DB2
Test with dbmonster (http://dbmonster.kernelpanic.pl/)
Test with dbcopy (http://dbcopyplugin.sourceforge.net)
Find a tool to view a text file >100 MB, with find, page up and down (like less)
Implement, test, document XAConnection and so on
Web site: meta keywords, description, get rid of frame set
Pluggable data type (for compression, validation, conversion, encryption)
CHECK: find out what makes CHECK=TRUE slow, move to CHECK2
Improve recovery: improve code for log recovery problems (less try/catch)
Log linear hash index changes, fast open / close
Index usage for (ID, NAME)=(1, 'Hi'); document
Suggestion: include jetty as Servlet Container (like LAMP)
Trace shipping to server
Performance / server mode: use UDP optionally?
Version check: docs / web console (using javascript), and maybe in the library (using TCP/IP)
Web server classloader: override findResource / getResourceFrom
Cost for embedded temporary view is calculated wrong, if result is constant
Comparison: pluggable sort order: natural sort
Count index range query (count(*) where id between 10 and 20)
Eclipse plugin
iReport to support H2
Implement missing JDBC API (CallableStatement,...)
Compression of the cache
Run H2 Console inside servlet (pass-through servlet of fix the JSP / app)
Include SMPT (mail) server (at least client) (alert on cluster failure, low disk space,...)
Drop with restrict (currently cascade is the default)
JSON parser and functions
Automatic collection of statistics (auto ANALYZE)
Server: client ping from time to time (to avoid timeout - is timeout a problem?)
Copy database: Tool with config GUI and batch mode, extensible (example: compare)
Document, implement tool for long running transactions using user-defined compensation statements
Support SET TABLE DUAL READONLY
Linked schema using CSV files: one schema for a directory of files; support indexes for CSV files
Don't write stack traces for common exceptions like duplicate key to the log by default
Setting for MAX_QUERY_TIME (default no limit?)
GCJ: what is the state now?
Use Janino to convert Java to C++
Reduce disk space usage (Derby uses less disk space?)
Events for: Database Startup, Connections, Login attempts, Disconnections, Prepare (after parsing), Web Server (see http://docs.openlinksw.com/virtuoso/fn_dbev_startup.html)
Optimization: Log compression
Support standard INFORMATION_SCHEMA tables, as defined in http://www.contrib.andrew.cmu.edu/~shadow/sql/sql1992.txt; specially KEY_COLUMN_USAGE (http://dev.mysql.com/doc/refman/5.0/en/information-schema.html, http://www.xcdsql.org/Misc/INFORMATION_SCHEMA%20With%20Rolenames.gif)
Compatibility: in MySQL, HSQLDB, /0.0 is NULL; in PostgreSQL, Derby: Division by zero
Functional tables should accept parameters from other tables (see FunctionMultiReturn) SELECT * FROM TEST T, P2C(T.A, T.R)
Custom class loader to reload functions on demand
Test http://mysql-je.sourceforge.net/
Close all files when closing the database (including LOB files that are open on the client side)
Test Connection Pool http://jakarta.apache.org/commons/dbcp
Profiler option or profiling tool to find long running and often repeated queries (using DatabaseEventListener API)
Function to read/write a file from/to LOB
Allow custom settings (@PATH for RUNSCRIPT for example)
EXE file: maybe use http://jsmooth.sourceforge.net
SELECT ... FOR READ WAIT [maxMillisToWait]
Automatically delete the index file if opening it fails
Performance: Automatically build in-memory indexes if the whole table is in memory
H2 Console: The webclient could support more features like phpMyAdmin.
The HELP information schema can be directly exposed in the Console
Maybe use the 0x1234 notation for binary fields, see MS SQL Server
Support Oracle CONNECT BY in some way: http://www.adp-gmbh.ch/ora/sql/connect_by.html, http://philip.greenspun.com/sql/trees.html
SQL 2003 (http://www.wiscorp.com/sql_2003_standard.zip)
http://www.jpackage.org
Version column (number/sequence and timestamp based)
Optimize getGeneratedKey: send last identity after each execute (server).
Date: default date is '1970-01-01' (is it 1900-01-01 in the standard / other databases?)
Test and document UPDATE TEST SET (ID, NAME) = (SELECT ID*10, NAME || '!' FROM TEST T WHERE T.ID=TEST.ID);
Max memory rows / max undo log size: use block count / row size not row count
Index summary is only written if log=2; maybe write it also when log=1 and everything is fine (and no in doubt transactions)
Support 123L syntax as in Java; example: SELECT (2000000000*2)
Implement point-in-time recovery
Memory database: add a feature to keep named database open until 'shutdown'
Use the directory of the first script as the default directory for any scripts run inside that script
Include the version name in the jar file name
Optimize ID=? OR ID=?: convert to IN(...)
LIKE: improved version for larger texts (currently using naive search)
Auto-reconnect on lost connection to server (even if the server was re-started) except if autocommit was off and there was pending transaction
The Script tool should work with other databases as well
Automatically convert to the next 'higher' data type whenever there is an overflow.
Throw an exception when the application calls getInt on a Long (optional)
Default date format for input and output (local date constants)
Cache collation keys for performance
ValueInt.convertToString and so on (remove Value.convertTo)
Support custom Collators
Document ROWNUM usage for reports: SELECT ROWNUM, * FROM (subquery)
Clustering: Reads should be randomly distributed or to a designated database on RAM
Clustering: When a database is back alive, automatically synchronize with the master
Standalone tool to get relevant system properties and add it to the trace output.
Support mixed clustering mode (one embedded, the other server mode)
Support 'call proc(1=value)' (PostgreSQL, Oracle)
HSQLDB compatibility: "INSERT INTO TEST(name) VALUES(?); SELECT IDENTITY()"
Shutdown lock (shutdown can only start if there are no logins pending, and logins are delayed until shutdown ends)
Automatically delete the index file if opening it fails
DbAdapters http://incubator.apache.org/cayenne/
JAMon (proxy jdbc driver)
Console: Allow setting Null value; Alternative display format two column (for copy and paste as well)
Console: Improve editing data (Tab, Shift-Tab, Enter, Up, Down, Shift+Del?)
Console: Autocomplete Ctrl+Space inserts template
Google Code http://code.google.com/p/h2database/issues/list#
Simplify translation ('Donate a translation')
Option to encrypt .trace.db file
Write Behind Cache on SATA leads to data corruption See also http://sr5tech.com/write_back_cache_experiments.htm and http://www.jasonbrome.com/blog/archives/2004/04/03/writecache_enabled.html
Functions with unknown return or parameter data types: serialize / deserialize
Test if idle TCP connections are closed, and how to disable that
Try using a factory for Row, Value[] (faster?), http://javolution.org/, alternative ObjectArray / IntArray
Auto-Update feature for database, .jar file
ResultSet SimpleResultSet.readFromURL(String url): id varchar, state varchar, released timestamp
RANK() and DENSE_RANK(), Partition using OVER()
ROW_NUMBER (not the same as ROWNUM)
Partial indexing (see PostgreSQL)
BUILD should fail if ant test fails
http://rubyforge.org/projects/hypersonic/
DbVisualizer profile for H2
Add comparator (x === y) : (x = y or (x is null and y is null))
Try to create trace file even for read only databases
Add a sample application that runs the H2 unit test and writes the result to a file (so it can be included in the user app)
Count on a column that can not be null would be optimized to COUNT(*)
Table order: ALTER TABLE TEST ORDER BY NAME DESC (MySQL compatibility)
Backup tool should work with other databases as well
Console: -ifExists doesn't work for the console. Add a flag to disable other dbs
Maybe use Fowler Noll Vo hash function
Improved full text search (supports LOBs, reader / tokenizer / filter).
Performance: Update in-place
Check if 'FSUTIL behavior set disablelastaccess 1' improves the performance (fsutil behavior query disablelastaccess)
Java static code analysis: http://pmd.sourceforge.net/
Java static code analysis: http://www.eclipse.org/tptp/
Compatibility for CREATE SCHEMA AUTHORIZATION
Implement Clob / Blob truncate and the remaining functionality
Maybe close LOBs after closing connection
Tree join functionality
Support alter table add column if table has views defined
Add multiple columns at the same time with ALTER TABLE .. ADD .. ADD ..
Support trigger on the tables information_schema.tables and ...columns
Add H2 to Gem (Ruby install system)
API for functions / user tables
Order conditions inside AND / OR to optimize the performance
Support linked JCR tables
Make sure H2 is supported by Execute Query: http://executequery.org/
Read InputStream when executing, as late as possible (maybe only embedded mode). Problem with re-execute.
Full text search: min word length; store word positions
FTP Server: Implement a client to send / receive files to server (dir, get, put)
FTP Server: Implement SFTP / FTPS
Add an option to the SCRIPT command to generate only portable / standard SQL
Test Dezign for Databases (http://www.datanamic.com)
Fast library for parsing / formatting: http://javolution.org/
Updatable Views (simple cases first)
Improve create index performance
Support ARRAY data type
Implement more JDBC 4.0 features
H2 Console: implement a servlet to allow simple web app integration
Support TRANSFORM / PIVOT as in MS Access
SELECT * FROM (VALUES (...), (...), ....) AS alias(f1, ...)
Support updatable views with join on primary keys (to extend a table)
Public interface for functions (not public static)
Autocomplete: if I type the name of a table that does not exist (should say: syntax not supported)
Autocomplete: schema support: "Other Grammar","Table Expression","{[schemaName.]tableName | (select)} [[AS] newTableAlias]
Functions: options readonly, deterministic (pure, always return the same value)
Document FTP server, including -ftpTask option to execute / kill remote processes
Add jdbcx to the javadocs
Delay reading the row if data is not required
Eliminate undo log records if stored on disk (just one pointer per block, not per record)
Feature matrix like in i-net software.
Updatable result set on table without primary key or unique index
Use LinkedList instead of ArrayList where applicable
Optimization: (A=B AND B=C) > (A=B AND B=C AND A=C)
Support % operator (modulo)
Large subqueries: close them when the main query is closed, not earlier (so result can be reused)
Support 1+'2'=3, '1'+'2'='12' (MS SQL Server compatibility)
Support nested transactions
Add a benchmark for big databases, and one for many users
Compression in the result set (repeating values in the same column)
Improve command line consistency (+/- options, or true false options)
Allow to use the catalog name in statements: [[catalog.]schema.]object
Support curtimestamp (like curtime, curdate)
Support ANALYZE {TABLE|INDEX} tableName COMPUTE|ESTIMATE|DELETE STATISTICS ptnOption options
Support Sequoia (Continuent.org)
Dynamic length numbers / special methods for DataPage.writeByte / writeShort / Ronni Nielsen
Pluggable ThreadPool, (AvalonDB / deebee / Paul Hammant)
Recursive Queries (see details)
Use index on boolean flag (see details)
Add build for embedded database only
Release locks (shared or exclusive) on demand
Support catalog names
Add object id to metadata tables
Support OUTER UNION
Support Parameterized Views (similar to CSVREAD, but using just SQL for the definition)
Implement a command line SQL utility similar to HenPlus: http://henplus.sourceforge.net
A way (JDBC driver) to map an URL (jdbc:h2map:c1) to a connection object
Build script for the embedded functionality only (h2embedded.jar)
Option for SCRIPT to only process one or a set of tables, and append to a file
Support using a unique index for IS NULL (including linked tables)
Support linked tables to the current database
Support dynamic linked schema (automatically adding/updating/removing tables)
Compatibility with Derby: VALUES(1), (2); SELECT * FROM (VALUES (1), (2)) AS myTable(c1)
Compatibility: # is the start of a single line comment (MySQL) but date quote (Access). Mode specific
Run benchmarks with JDK 1.5, JDK 1.6, java -server
Optimizations: Faster hash function for strings, byte arrays, big decimal
DatabaseEventListener: callback for all operations (including expected time, RUNSCRIPT) and cancel functionality
H2 Console / large result sets: use 'streaming' instead of building the page in-memory
Benchmark: add a graph to show how databases scale (performance/database size)
Implement a SQLData interface to map your data over to a custom object
Extend H2 Console to run tools (show command line as well)
Make DDL (Data Definition) operations transactional
Allow execution time prepare for SELECT * FROM CSVREAD(?, 'columnNameString')
Support multiple directories (on different hard drives) for the same database
Server protocol: use challenge response authentication, but client sends hash(user+password) encrypted with response
Support EXEC[UTE] (doesn't return a result set, compatible to MS SQL Server)
GROUP BY and DISTINCT: support large groups (buffer to disk), do not keep large sets in memory
Support native XML data type
Support triggers with a string property or option: SpringTrigger, OSGITrigger
Clustering: adding a node should be very fast and without interrupting clients (very short lock)
Support materialized views (using triggers)
Store dates in local time zone (portability of database files)
Ability to resize the cache array when resizing the cache
Automatic conversion from WHERE X>10 AND X>20 to X>20
Time based cache writing (one second after writing the log)
Check state of H2 driver for DDLUtils: https://issues.apache.org/jira/browse/DDLUTILS-185
Index usage for REGEXP LIKE.
Add a role DBA (like ADMIN).
Better support multiple processors for in-memory databases.
Access rights: remember the owner of an object. COMMENT: allow owner of object to change it.
Implement INSTEAD OF trigger.
Access rights: Finer grained access control (grant access for specific functions)
Support N'text'
Support SCOPE_IDENTITY() to avoid problems when inserting rows in a trigger
Support DESCRIBE like MySQL or Oracle (DESC|DESCRIBE {[schema.]object[@connect_identifier]})
Set a connection read only (Connection.setReadOnly)
In MySQL mode, for AUTO_INCREMENT columns, don't set the primary key
Use JDK 1.4 file locking to create the lock file (but not yet by default); writing a system property to detect concurrent access from the same VM (different classloaders).
Read-only sessions (Connection.setReadOnly)
Support compatibility for jdbc:hsqldb:res:
In the MySQL and PostgreSQL, use lower case identifiers by default (DatabaseMetaData.storesLowerCaseIdentifiers = true)
Provide a simple, lightweight O/R mapping tool
Provide an Java SQL builder with standard and H2 syntax
Trace: write OS, file system, JVM,... when opening the database
Trace: write dangerous operations (set log 0,...) in every case (including when opening the database)
Support indexes for views (probably requires materialized views)
Linked tables that point to the same database should share the connection
Document SET SEARCH_PATH, BEGIN, EXECUTE, parameters
Complete Javadocs for ErrorCode messages and add to docs
Browser: use Desktop.isDesktopSupported and browse when using JDK 1.6
Document org.h2.samples.MixedMode
Server: use one listener (detect if the request comes from an PG or TCP client)
Store dates as 'local'. Existing files use GMT. Use escape syntax for compatibility.
Support data type INTERVAL
NATURAL JOIN: MySQL and PostgreSQL don't repeat columns when using SELECT * ...
Optimize SELECT MIN(ID), MAX(ID), COUNT(*) FROM TEST WHERE ID BETWEEN 100 AND 200
Support Oracle functions: TRUNC, NVL2, TO_CHAR, TO_DATE, TO_NUMBER
Support setQueryTimeout (using System.currentTimeMillis in a loop; not using a thread)
Sequence: PostgreSQL compatibility (rename, create) (http://www.postgresql.org/docs/8.2/static/sql-altersequence.html)
DISTINCT: Support large result sets by sorting on all columns (additionally) and then removing duplicates.
Add replicating file system
File system that writes to two file systems (for replication)
File system with a background writer thread; test if this is faster
FTP access to a database (.csv for a table, a directory for a schema, a file for a lob, a script.sql file).
LIMIT and OFFSET for GROUP_CONCAT
Support triggers for INFORMATION_SCHEMA tables (to better support PostgreSQL catalog: rebuild after creating new tables)
Better document the source code
Support select * from dual a left join dual b on b.x=(select max(x) from dual)
Optimization: don't lock when the database is read-only
Integrate spatial functions from http://geosysin.iict.ch/irstv-trac/wiki/H2spatial/Download
Support COSH, SINH, and TANH functions
Native search: support "phrase search", wildcard search (* and ?), case-insensitive search, boolean operators, and grouping
Improve documentation of access rights
Support ENUM data type (see MySQL, PostgreSQL, MS SQL Server, maybe others)
Command line option for the H2 Console and TCP configuration (.h2.server.properties and .h2.keystore)
Automatically switch the source code to the right platform before compiling
Support a schema name for Java functions
Remember the domain of a column
Support Jackcess (MS Access databases)
Optimize truncate and drop table (currently all pages are overwritten)
Built-in methods to write large objects (BLOB and CLOB): FILE_WRITE('test.txt', 'Hello World')
Change package name in version 2.0: org.h2database
MVCC: support transactionally consistent backups using SCRIPT
Improve time to open large databases (see mail 'init time for distributed setup')
Use ARRAY for fulltext search return value, at least internally in the native implementation (and as an option for the user)
Move Maven 2 repository from hsql.sf.net to h2database.sf.net
Java 1.5 tool: JdbcUtils.closeSilently(s1, s2,...)
Document how to use IKVM
Javadoc: document design patterns used
Update Wikipedia
Try https://hudson.dev.java.net/
Don't create @~ of not translated
Triggers for metadata tables; use for PostgreSQL catalog
Does the FTP server has problems with multithreading?
Write an article about SQLInjection (h2\src\docsrc\html\images\SQLInjection.txt)
Convert SQL-injection-2.txt to html document, include SQLInjection.java sample
Send SQL Injection solution proposal to PostgreSQL, MySQL, Derby, HSQLDB,...
Improve LOB in directories performance
Web site design: http://www.igniterealtime.org/projects/openfire/index.jsp
HSQLDB compatibility: Openfire server uses: CREATE SCHEMA PUBLIC AUTHORIZATION DBA; CREATE USER SA PASSWORD ""; GRANT DBA TO SA; SET SCHEMA PUBLIC
Web site: Rename Performance to Comparison [/Compatibility], move Comparison to Other Database Engines to Comparison, move Products that Work with H2 to Comparison, move Performance Tuning to Advanced Topics
Translation: use ${.} in help.csv
Translated .pdf
Cluster: hot deploy (adding a node on runtime)
Test with PostgreSQL Version 8.2
Submit again to http://www.docjar.com/
Website: Don't use frames.
Try again with Lobo browser (pure Java)
Recovery tool: bad blocks should be converted to INSERT INTO SYSTEM_ERRORS(...), and things should go into the .trace.db file
RECOVER=2 to backup the database, run recovery, open the database
Recovery should work with encrypted databases
Integrate tools in H2 Console
Corruption: new error code, add help
Space reuse: after init, scan all storages and free those that don't belong to a live database object
SysProperties: change everything to H2_...
Use FilterIn / FilterOut putStream?
Access rights: add missing features (users should be 'owner' of objects; missing rights for sequences; dropping objects)
Support NOCACHE table option (Oracle)
Use ant 'get' to download dependencies
Index usage for UPDATE ... WHERE .. IN (SELECT...)
The RunScript tool should support interactive mode (reading from system in). Password using a second thread.
Add regular javadocs to the homepage.
The database should be kept open for a longer time when using the server mode.
Javadocs: for each tool, add a copy & paste sample in the class level.
Add google site search to web page.
Javadocs: add @author tags.
SET LOG_SYSTEM {NATIVE|LOG4J|COMMONS|DRIVER_MANAGER}
Fluent API for tools: Server.createTcpServer().setPort(9081).setPassword(password).start();
MySQL compatibility: SHOW TABLES, DESCRIBE TEST (then remove from Shell)
Use a default delay of 1 second before closing a database.
Maven: upload source code and javadocs as well
Write (log) to system table before adding to internal data structures
Support very large deletes and updates
Doclet (javadocs): constructors are not listed
Support direct lookup for MIN and MAX when using WHERE (see todo.txt / Direct Lookup)
Support other array types (String[], double[]) in PreparedStatement.setObject(int, Object);

Not Planned

HSQLDB (did) support this: select id i from test where i>0 (other databases don't). Supporting it may break compatibility.
String.intern (so that Strings can be compared with ==) will not be used because some VMs have problems when used extensively.