Wie lässt sich in Java eine eingebettete Datenbank realisieren?
Die gesamte Routine wird von einem try-catch-Block umschlossen,
um SQL-Exceptions abzufangen.
Als erstes muss der Treiber
geladen werden:
Class.forName("org.h2.Driver");
Hierzu ist es notwendig, die jeweils aktuelle Jar-Datei unter http://www.h2database.com/html/download.html
herunterzuladen und in den Classpath einzubinden. Vergessen Sie
auch nicht, bei Verwendung von Eclipse die Datei in den
Build-Path aufzunehmen. (Project-Properties → Java Build
Path).
Der nächste Schritt besteht darin, eine
Verbindung zur Datenbank aufzubauen. Dies geschieht durch die
statische Methode DriverManager.getConnection(). Sie
erwartet drei Parameter
- den URL zur Datenbankdatei
- den Nutzernamen
- das Zugangs-Passwort
Der Datenbank-URL muss in der Form jdbc:h2:<PfadZurDatei>
angegeben werden, wobei der Pfad relativ oder absolut angegeben
werden kann. Ist keine Datenbank-Datei angelegt, so wird sie
gebildet. Im Beispiel befindet sie sich im versteckten
Verzeichnis <UserHome>/.javabeginners und
trägt den Namen h2Test.h2.db. Die Dateiendung h2.db
darf nicht mit angegeben werden. Wird kein Pfad angegeben, so
wird das aktuelle Arbeitsverzeichnis als Speicherort verwendet.
Nutzername und Passwort sind optional und können leer
bleiben, bzw. selbstverständlich wie auch der Datenbankname
über eine Benutzeroberfläche dynamisch zur Laufzeit
eingegeben werden. Auf diese Weise könnten z.B.
individuelle Programm-Einstellungen gespeichert werden.
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class H2Class {
public static void main(String[] a) throws Exception {
Connection conn = null;
String tab = "TESTTABELLE";
try {
Class.forName("org.h2.Driver");
conn = DriverManager.getConnection(
"jdbc:h2:~/.javabeginners/h2Test", "", "");
DatabaseMetaData md = conn.getMetaData();
String[] types = { "TABLE", "SYSTEM TABLE" };
ResultSet metaRS = md.getTables(null, null, "%", types);
while (metaRS.next()) {
// Catalog
String tableCatalog = metaRS.getString(1);
System.out.println("Catalog: " + tableCatalog);
// Schemata
String tableSchema = metaRS.getString(2);
System.out.println("Tabellen-Schema: " + tableSchema);
// Tabellennamen
String tableName = metaRS.getString(3);
System.out.println("Tabellen-Name: " + tableName);
// Tabellentyp
String tableType = metaRS.getString(4);
System.out.println("Tabellen-Typ: " + tableType + "\n");
}
Statement stmt = conn.createStatement();
String dropQ = "DROP TABLE IF EXISTS " + tab;
stmt.executeUpdate(dropQ);
String createQ = "CREATE TABLE IF NOT EXISTS "
+ tab
+ "(ID INT PRIMARY KEY AUTO_INCREMENT(1,1) NOT NULL, NAME VARCHAR(255))";
stmt.executeUpdate(createQ);
String insertQ = "INSERT INTO " + tab
+ " VALUES(TRANSACTION_ID(),'Hello World!')";
stmt.executeUpdate(insertQ);
ResultSet selectRS = stmt.executeQuery("SELECT * FROM " + tab);
while (selectRS.next()) {
System.out.printf("%s, %s\n", selectRS.getString(1),
selectRS.getString(2));
}
System.out.println("Liste Tabellen...");
String tablesQ = "SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA='PUBLIC'";
ResultSet tablesRS = stmt.executeQuery(tablesQ);
while (tablesRS.next()) {
System.out.printf("Tabelle %s vorhanden \n",
tablesRS.getString(1));
}
conn.close();
} catch (SQLException e) {
e.printStackTrace();
} finally {
if (conn != null)
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
Tabellen-Metadaten auslesen
Über das Connection-Objekt werden mit Hilfe der Methode getMetaData()
die Meta-Daten der Datenbank abgerufen. Sie müssen nun nach
den gewünschten Typen gefiltert werden. Dies geschieht
durch die Übergabe eines String-Arrays, in das diese
eingetragen werden, an die Methode getTables() des
DatabaseMetaData-Objektes. Im Beispiel werden die Metadaten der
System-Tabellen und der vom Nutzer angelegten Tabellen
abgefragt. Möchte man nur die Ausgaben für die
Nutzertabellen abfragen, so entfernt man den Eintrag SYSTEM
TABLE aus dem Array.
Neben
den genannten können hier auch die folgenden Typen
gewählt werden:
- "VIEW"
- "GLOBAL TEMPORARY"
- "LOCAL TEMPORARY"
- "ALIAS"
- "SYNONYM"
Die anderen drei Parameter, catalog, schemaPattern
und tableNamePattern, können verwendet werden, um
die Suche weiter einzuschränken. Die Angabe null
für die ersten beiden Parameter bewirkt, dass diese
Einschränkungen nicht verwendet werden. Das Prozentzeichen
% des dritten Parameters bewirkt das Auslesen aller
eingetragenen Tabellen.
In der Folge wird über das ResultSet
iteriert, um die Einträge auszugeben.
Abfragen und Updates
Das Interface java.sql.Statement liefert ein Objekt zum Absetzen von Datenbank-Anfragen und zur Ausgabe der entsprechenden Ergebnisse. Im Beispiel werden auf ihm zwei verschiedene Methoden aufgerufen:
- executeUpdate() liefert einen int-Wert und wird für INSERT-, UPDATE- und DELETE-Statements verwendet. Der Statement-String wird als Parameter übergeben.
- executeQuery() liefert ein ResultSet und wird üblicherweise für SELECT-Abfragen eingesetzt.
Die Tabelle mit dem in der Variablen tab gespeicherten Namen wird im Folgenden der Reihe nach
- gelöscht, falls sie bereits existiert
- neu erzeugt, falls sie noch nicht existieren sollte
Hier fällt die SQL-Funktion AUTO_INCREMENT(1,1) auf. Die Parameter geben an, dass die automatische Incrementierung des ID-Wertes bei 1 beginnen und in Einer-Schritten erfolgen soll. - mit einem neuen Eintrag versehen
Hier ist zu beachten, dass der Auto-Increment-Wert der ID nicht, wie etwa bei MySQL, selbstständig erzeugt und incrementiert wird, sondern, dass hierfür die Funktion TRANSACTION_ID() eingetragen werden muss. - ausgelesen
Den Abschluss bildet eine weitere Form der Ermittlung der existierenden User-Tabellen: Auch hier stellt eine SELECT-Abfrage die Grundlage dar, um ein ResultSet zu erhalten, das durchlaufen und ausgegeben werden kann. Mit conn.close() wird die Verbindung zur Datenbank schließlich geschlossen.
