0
# H2 Database Engine
1

2
H2 Database Engine is a very fast, open source, JDBC API database with embedded and server modes, transaction support, multi-version concurrency, browser-based console application, encrypted databases, fulltext search, and pure Java implementation with small footprint. H2 supports both in-memory and persistent databases, making it ideal for development, testing, embedded applications, and production systems requiring a lightweight yet powerful SQL database solution.
3

4
## Package Information
5

6
- **Package Name**: com.h2database:h2
7
- **Package Type**: Maven
8
- **Language**: Java
9
- **Installation**: Add to Maven `pom.xml`:
10
  ```xml
11
  <dependency>
12
    <groupId>com.h2database</groupId>
13
    <artifactId>h2</artifactId>
14
    <version>2.3.232</version>
15
  </dependency>
16
  ```
17
- **Gradle**: `implementation 'com.h2database:h2:2.3.232'`
18

19
## Core Imports
20

21
```java
22
import org.h2.Driver;
23
import org.h2.jdbcx.JdbcDataSource;
24
```
25

26
For JDBC usage:
27
```java
28
import java.sql.*;
29
```
30

31
For tools and utilities:
32
```java
33
import org.h2.tools.*;
34
```
35

36
## Basic Usage
37

38
### Simple Embedded Database
39

40
```java
41
import java.sql.*;
42

43
public class H2Example {
44
    public static void main(String[] args) throws SQLException {
45
        // Register H2 driver (optional in modern Java)
46
        Class.forName("org.h2.Driver");
47
        
48
        // Create in-memory database connection
49
        Connection conn = DriverManager.getConnection(
50
            "jdbc:h2:mem:testdb", "sa", "");
51
        
52
        // Create table and insert data
53
        Statement stmt = conn.createStatement();
54
        stmt.execute("CREATE TABLE users (id INT PRIMARY KEY, name VARCHAR(255))");
55
        stmt.execute("INSERT INTO users VALUES (1, 'Alice'), (2, 'Bob')");
56
        
57
        // Query data
58
        ResultSet rs = stmt.executeQuery("SELECT * FROM users");
59
        while (rs.next()) {
60
            System.out.println("ID: " + rs.getInt("id") + 
61
                             ", Name: " + rs.getString("name"));
62
        }
63
        
64
        // Close connection
65
        conn.close();
66
    }
67
}
68
```
69

70
### Persistent Database
71

72
```java
73
// File-based database (creates testdb.mv.db file)
74
Connection conn = DriverManager.getConnection(
75
    "jdbc:h2:~/testdb", "sa", "password");
76
```
77

78
### Using DataSource
79

80
```java
81
import org.h2.jdbcx.JdbcDataSource;
82

83
JdbcDataSource ds = new JdbcDataSource();
84
ds.setURL("jdbc:h2:mem:testdb");
85
ds.setUser("sa");
86
ds.setPassword("");
87

88
Connection conn = ds.getConnection();
89
```
90

91
## Architecture
92

93
H2 Database Engine is built around several key components:
94

95
- **JDBC Driver**: Standard JDBC 4.2 compliant driver for database connectivity
96
- **Database Engine**: Core SQL processing engine with full ACID transaction support
97
- **MVStore**: Advanced storage engine providing MVCC (Multi-Version Concurrency Control)
98
- **Server Components**: TCP server, Web console, and PostgreSQL compatibility server
99
- **Administrative Tools**: Command-line utilities for backup, restore, scripting, and maintenance
100
- **Extension APIs**: Interfaces for custom triggers, aggregates, table engines, and event listeners
101

102
## Capabilities
103

104
### JDBC Connectivity
105

106
Standard JDBC database connectivity with H2-specific enhancements for embedded and server modes. Supports connection pooling, XA transactions, and various authentication methods.
107

108
```java { .api }
109
public class Driver implements java.sql.Driver {
110
    public Connection connect(String url, Properties info) throws SQLException;
111
    public boolean acceptsURL(String url) throws SQLException;
112
    public static Driver load();
113
}
114
```
115

116
```java { .api }
117
public class JdbcDataSource implements DataSource, XADataSource, ConnectionPoolDataSource {
118
    public Connection getConnection() throws SQLException;
119
    public Connection getConnection(String username, String password) throws SQLException;
120
    public void setURL(String url);
121
    public void setUser(String user);
122
    public void setPassword(String password);
123
}
124
```
125

126
[JDBC Connectivity](./jdbc.md)
127

128
### Administrative Tools
129

130
Comprehensive set of command-line tools for database administration, maintenance, and data management operations.
131

132
```java { .api }
133
public class Server extends Tool implements Runnable {
134
    public static void main(String... args);
135
    public Server();
136
    public Server(Service service, String... args);
137
}
138
```
139

140
```java { .api }
141
public class Script extends Tool {
142
    public static void main(String... args);
143
}
144
```
145

146
```java { .api }
147
public class Backup extends Tool {
148
    public static void main(String... args);
149
}
150
```
151

152
[Tools and Utilities](./tools.md)
153

154
### Embedded MVStore
155

156
High-performance key-value storage engine that can be used independently of the SQL database. Provides persistent maps with ACID transactions and MVCC.
157

158
```java { .api }
159
public class MVStore implements AutoCloseable {
160
    public static MVStore open(String fileName);
161
    public <K, V> MVMap<K, V> openMap(String name);
162
    public Set<String> getMapNames();
163
    public void close();
164
}
165
```
166

167
```java { .api }
168
public class MVMap<K, V> {
169
    public V put(K key, V value);
170
    public V get(Object key);
171
    public V remove(Object key);
172
    public long size();
173
}
174
```
175

176
[Embedded MVStore](./mvstore.md)
177

178
### Server Deployment
179

180
Server components for deploying H2 as a standalone database server with support for multiple client connections, web-based administration, and PostgreSQL protocol compatibility.
181

182
```java { .api }
183
public class TcpServer {
184
    // TCP/IP database server implementation
185
}
186
```
187

188
```java { .api }
189
public class WebServer {
190
    // HTTP server for H2 Console web interface
191
}
192
```
193

194
```java { .api }
195
public class PgServer {
196
    // PostgreSQL protocol compatibility server
197
}
198
```
199

200
[Server Deployment](./server.md)
201

202
### Extension APIs
203

204
Interfaces for extending H2 Database functionality with custom triggers, aggregate functions, table engines, and event listeners.
205

206
```java { .api }
207
public interface Trigger {
208
    int INSERT = 1;
209
    int UPDATE = 2;
210
    int DELETE = 4;
211
    int SELECT = 8;
212
    
213
    void fire(Connection conn, Object[] oldRow, Object[] newRow) throws SQLException;
214
    default void init(Connection conn, String schemaName, String triggerName, 
215
                     String tableName, boolean before, int type) throws SQLException;
216
}
217
```
218

219
```java { .api }
220
public interface AggregateFunction {
221
    void add(Object value) throws SQLException;
222
    Object getResult() throws SQLException;
223
    int getType(int[] inputTypes) throws SQLException;
224
}
225
```
226

227
```java { .api }
228
public interface DatabaseEventListener extends EventListener {
229
    default void exceptionThrown(SQLException e, String sql);
230
    default void setProgress(int state, String name, long x, long max);
231
}
232
```
233

234
[Extension APIs](./extensions.md)
235

236
## Common Connection URLs
237

238
- **In-memory database**: `jdbc:h2:mem:dbname`
239
- **File database**: `jdbc:h2:~/dbname` or `jdbc:h2:./dbname`
240
- **Encrypted database**: `jdbc:h2:~/secure;CIPHER=AES`
241
- **TCP server**: `jdbc:h2:tcp://localhost/~/dbname`
242
- **SSL connection**: `jdbc:h2:ssl://localhost/~/dbname`
243
- **Mixed mode**: `jdbc:h2:~/dbname;AUTO_SERVER=TRUE`
244
- **Read-only**: `jdbc:h2:~/dbname;ACCESS_MODE_DATA=r`
245

246
## Error Handling
247

248
H2 uses standard SQLException hierarchy with H2-specific error codes defined in ErrorCode class:
249

250
```java { .api }
251
public class ErrorCode {
252
    public static final int NO_DATA_AVAILABLE = 2000;
253
    // ... numerous other error codes
254
}
255
```
256

257
Common patterns:
258
```java
259
try {
260
    Connection conn = DriverManager.getConnection("jdbc:h2:mem:test", "sa", "");
261
    // database operations
262
} catch (SQLException e) {
263
    System.err.println("Error Code: " + e.getErrorCode());
264
    System.err.println("SQL State: " + e.getSQLState());
265
    System.err.println("Message: " + e.getMessage());
266
}
267
```