Von einer Datenbank können verschiedene Informationen ausgelesen werden. Zum einen sind dies Informationen zu einer bestimmten Tabelle, zum anderen Informationen über die Datenbank selbst.

Metadaten über die Tabelle

Bei der Abfrage über alle Spalten müssen wir die Struktur der Datenbank kennen, insbesondere dann, wenn wir allgemeine Abfragen vornehmen und die passenden Daten herauslesen wollen. So liefert SELECT * FROM Item ein ResultSet mit der Anzahl der Spalten, wie sie die Tabelle Item hat. Doch bevor wir nicht die Anzahl und die Art der Spalten kennen, können wir nicht auf die Daten zugreifen.

Um diese Art von Informationen, so genannte Metadaten, in Erfahrung zu bringen, befindet sich die Klasse ResultSetMetaData, mit der wir diese Informationen erhalten, unter den SQL-Klassen. Metadaten können für jede Abfrage angefordert werden. So lässt sich unter anderem leicht herausfinden:

• wie viele Spalten wir in einer Zeile abfragen können
• wie der Name der Spalte lautet
• welchen SQL-Typ die Spalte hat
• ob NULL für eine Spalte in Ordnung ist
• wie viele Dezimalzeichen eine Spalte hat

Einige Informationen über die Bestellelemente

Um Anzahl und Art der Spalten einer Bestelltabelle herauszufinden, werden wir zunächst ein ResultSet mit stmt.executeQuery(„SELECT * FROM Item“) erzeugen und dann via getMetaData() ein ResultSetMetaData-Objekt erfragen. Das ResultSetMetaData-Objekt besitzt viele Methoden, um Aussagen über die Tabelle und die Spalten zu treffen. So fragen wir mit getColumnCount() nach, wie viele Spalten die Tabelle hat. Anschließend lässt sich für jede Spalte der Name und Typ erfragen:

String url = "jdbc:hsqldb:file:TutegoDB;shutdown=true";

String sql = "SELECT * FROM ITEM";

try ( Connection con = DriverManager.getConnection( url, "sa", "" );

      Statement stmt = con.createStatement();

      ResultSet rs = con.createStatement().executeQuery( sql ) ) {

  ResultSetMetaData meta = rs.getMetaData();

  int numerics = 0;

  for ( int i = 1; i <= meta.getColumnCount(); i++ ) {

    System.out.printf( "%-20s %-20s%n", meta.getColumnLabel( i ),

                                        meta.getColumnTypeName( i ) );

    if ( meta.isSigned( i ) )

      numerics++;

  }

  System.out.println();

  System.out.println( "Spalten: " + meta.getColumnCount() +

                      ", Numerisch: " + numerics );

}

interface java.sql.ResultSet
extends Wrapper, AutoCloseable

• ResultSetMetaDatagetMetaData()throwsSQLException
  Liefert die Eigenschaften eines ResultSet in einem ResultSetMetaData zurück.

interface java.sql.ResultSetMetaData
extends Wrapper

• intgetColumnCount()
  Liefert die Anzahl der Spalten im aktuellen ResultSet. Das ist praktisch für SQL-Anweisungen wie SELECT *.

Allen folgenden Methoden wird ein int übergeben, das die Spalte kennzeichnet:

• StringgetCatalogName(intcolumn)
  Gibt den String mit dem Katalognamen der Tabelle für die angegebene Spalte zurück.
• StringgetColumnName(intcolumn)
  Liefert den Spaltennamen der Tabelle.
• intgetColumnDisplaySize(intcolumn)
  Maximale Anzahl der Zeichen, die die Spalte einnimmt. So ist bei einer Spalte vom Typ VARCHAR(11) mit einer maximalen Spaltenbreite von zehn Zeichen zu rechnen. Bei numerischen Spalten variiert der Wert.
• StringgetColumnLabel(intcolumn)
  Gibt einen String zurück, der den Titel der angegebenen Spalte enthält. Der Titel gibt an, welche Überschrift für die Spalte angezeigt werden soll. Einige Datenbanken erlauben die Unterscheidung zwischen Spaltennamen und Spaltentitel.
• intgetColumnType(intcolumn)
  Der Typ der Spalte wird ermittelt. Der Spaltentyp ist dabei eine Konstante aus der Klasse java.sql.Types. Sie deklariert Konstanten nach dem XOPEN-Standard. Dazu zählen unter anderem BIGINT, BINARY, BIT, BLOB_LOCATOR, CHAR, CLOB_LOCATOR, DATE, DECIMAL, DISTINCT, DOUBLE, FLOAT, INTEGER, JAVA_OBJECT (benutzerdefinierter Datentyp), STRUCT, TIME, TIMESTAMP, TINYINT, VARBINARY, VARCHAR. Die Konstante OTHER zeigt ein datenbankspezifisches Element an und wird auf ein Java-Objekt abgebildet, falls ein Zugriff mittels getObject(…) oder setObject(…) erfolgt.
• StringgetColumnTypeName(intcolumn)
  Liefert den Namen der Spalte, so wie sie die Datenbank definiert.
• intgetPrecision(intcolumn)
  Liefert die Dezimalgenauigkeit der Spalte, zurückgegeben als Anzahl der Ziffern.
• intgetScale(intcolumn)
  Liefert die Genauigkeit der Spalte. Dies ist die Anzahl der Stellen, die nach dem Dezimalpunkt verwendet werden können.
• StringgetSchemaName(intcolumn)
  Der Name des Tabellenschemas. Wird von den Methoden des DatabaseMetaData-Objekts benutzt. Falls kein Schema vorhanden ist, wird „“ zurückgegeben.
• StringgetTableName(intcolumn)
  Liefert den Tabellennamen der angegebenen Spalte.
• booleanisAutoIncrement(intcolumn)
  Stellt fest, ob eine Spalte eine Auto-Increment-Spalte ist. Diese nimmt dann automatisch den nächsten freien Wert an, wenn ein neuer Datensatz eingefügt wird. Ist die erste Zeile einer Tabelle mit einer Auto-Increment-Spalte eingefügt, so nimmt die Spalte den Wert 1 an. In den meisten Datenbanken ist es allerdings nicht möglich, eigene Werte in diesen Spalten einzutragen.
• booleanisCaseSensitive(intcolumn)
  Berücksichtigt die Spalte die Groß- bzw. Kleinschreibung?
• booleanisCurrency(intcolumn)
  Enthält die Spalte Geldwerte? Nur einige Datenbanken bieten diesen Spaltentyp.
• booleanisNullable(intcolumn)
  Ist ein SQL-NULL in der Spalte erlaubt?
• booleanisSearchable(intcolumn)
  Kann die Spalte in einer SQL-WHERE-Klausel verwendet werden?
• booleanisSigned(intcolumn)
  Enthält die Spalte vorzeichenbehaftete Datentypen? Vorzeichenbehaftete Typen sind unter anderem INT, LONGINT und SMALLINT. Vorzeichenlose Typen sind unter anderem UINT, ULONG und UBYTE.
• booleanisReadOnly(intcolumn)
  Ist es möglich, auf die Spalte definitiv nicht schreibend zuzugreifen? Ist das Ergebnis true, kann der Wert also nicht aktualisiert werden.
• booleanisWritable(intcolumn)
  Ist es prinzipiell möglich, auf die Spalte schreibend zuzugreifen? Häufig wird das als !isReadOnly(column) implementiert.
• booleanisDefinitelyWritable(intcolumn)
  Kann auf die Spalte definitiv schreibend zugegriffen werden? Viele Datenbanken liefern die gleichen Ergebnisse bei isDefinitelyWritable(…) und isWritable(…). Prinzipiell könnte der Zustand von isWritable(…) abweichen, wenn sich zum Beispiel die Schreibbarkeit dynamisch ändert.

Alle Methoden können eine SQLException auslösen.

Informationen über die Datenbank

Metadaten sind auch für die gesamte Datenbank abfragbar. Beispiele für diese Informationen sind:

• Welche Tabellen liegen in der Datenbank?
• Wer ist mit der Datenbank verbunden?
• Kann die Datenbank nur gelesen oder kann auch in die Datenbank geschrieben werden?
• Wie lauten die Primärschlüssel für eine Tabelle?
• Sind gespeicherte Prozeduren auf der Datenbankseite erlaubt?
• Lassen sich äußere Joins (outer joins) durchführen?

Sind Informationen über die Datenbank gefragt, so lassen sich über Metadaten eines DatabaseMetaData-Objekts beispielsweise Datenbankeigenschaften des Herstellers herausfinden. Zunächst benötigen wir dazu ein DatabaseMetaData-Objekt, das uns getMetaData() von einer Connection gibt. Das DatabaseMetaData-Objekt deklariert eine große Anzahl Methoden:

DatabaseMetaData meta = con.getMetaData();
System.out.println( "Product name " + meta.getDatabaseProductName() );
System.out.println( "Version: " + meta.getDatabaseProductVersion()  );
System.out.println( "Maximum number of connections: " + meta.getMaxConnections() );
System.out.println( "JDBC driver version: " + meta.getDriverVersion() );
System.out.println( "Supports update in batch: " + meta.supportsBatchUpdates() );
System.out.println( "Supports stored procedures: " + meta.supportsStoredProcedures() );

Groovy (http://groovy.codehaus.org/) ist eine objektorientierte Skriptsprache, die auf einer JVM läuft und vollen Zugriff auf alle Java-Bibliotheken bietet. Die Sprache hat viele interessante Eigenschaften, die sie zu Java X machen. Groovy setzt auf der Standard-Java-Syntax auf und erweitert diese.[1] Einige Höhepunkte:

Eigenschaften von Groovy mit Beispiel

Groovy-Skripte in Eclipse ausführen

Um Groovy-Skripte und Programme auszuführen, bieten sich drei Wege an:

• über eine spezielle Kommandozeile, die Groovy-Shell
• über das Eclipse-Plugin
• über die javax.script-API

Das Eclipse-Plugin unter http://groovy.codehaus.org/Eclipse+Plugin leistet gute Arbeit und wird ständig weiterentwickelt. Auf der Webseite ist der Update-Link genannt, sodass Groovy-Eclipse über den Update-Manager installiert werden kann.

1. Wähle dazu Eclipse Help • Install New Software…
2. In der Dialogbox fülle das Textfeld bei Work with mit dem Link http://dist.springsource.org/release/GRECLIPSE/e4.3/ (bzw. anderen Versionen je nach Eclipse-Version), und aktiviere Add…
3. Aktiviere anschließend Groovy-Eclipse, und führe die Installation mit Next usw. zu Ende.

Ist Eclipse neu gestartet und das Plugin installiert, kann jedes Java-Projekt um Groovy-Unterstützung erweitert werden. Bei einem Java-Projekt aktiviert die Aktion Configure • Convert to Groovy Project im Kontextmenü genau diese Groovy-Unterstützung, sodass im Projektbaum die Groovy-Bibliotheken auftauchen.

File • New • Other… ermöglicht zum einen im Zweig Groovy das Erstellen eines neuen Groovy-Projekts (durch die Konvertierung eines existierenden Java-Projekts ist das nicht mehr nötig) und zum anderen mit Groovy Class das Erstellen einer Groovy-Klasse. Bei dieser Option lässt sich ein Paket- und Klassenname eingeben (etwa com.tutego.insel.script und GroovyBabe), und dann öffnet Eclipse den Groovy-Editor.

Löschen wir die Klassendeklaration und setzen nur die zwei Zeilen in die Datei:

package com.tutego.insel.script

print „Hallo Groovy“

Ausgeführt wird das Groovy-Skript im Kontextmenü (oder Run-Menü) mit Run As • Groovy Skript.

Groovy über die Skript-API ausführen

Um Groovy als Skriptsprache aus einem Java-Programm heraus zu nutzen, können wir wieder auf die Skript-API zurückgreifen. Wenn es sich bei Eclipse schon um ein Groovy-Projekt handelt, ist ein JAR schon im Klassenpfad eingebunden, und es ist nichts zu tun. Andernfalls bekommen wir von der Webseite http://groovy.codehaus.org/Download unter Download zip: Binary Release ein fast 30 MiB großes ZIP-Archiv wie groovy-binary-2.2.2.zip, wo groovy-all-2.2.2.jar im Ordner embeddable liegt und das wir in den Klassenpfad mit aufnehmen.

Ein kleines Beispiel:

ScriptEngine engine = new ScriptEngineManager().getEngineByName( "groovy" );

 System.out.println( engine.eval( "(1g..42g.gcd(56g)).sum()" ) ); // 105

[1]    Bis auf sehr kleine Ausnahmen ist jedes Java-Programm ein Groovy-Programm.

Eine der Schwachstellen in der Datumsverarbeitung ist das Fehlen eines Typs für Dauern (wenn wir von TimeUnit einmal absehen). Ein eigenständiger Typ bringt Vorteile, wenn es zum Beispiel darum geht, Dauern zu addieren (»Was ergibt 1 Woche plus 2 Monate?«) oder zu vergleichen (»Ist 1 Stunde mehr als 123456789 Millisekunden?«). Zwar lassen sich mit der add(…)-Methode von Calendar einzelne Segmente ändern, und dadurch lässt sich ein früherer oder späterer Zeitpunkt ansteuern, aber das ist wenig objektorientiert. Besser ist ein eigener Datentyp, der auch Operationen anbietet, um die Dauer auf ein Calendar- oder Date-Objekt zu setzen.

DatatypeFactory als Fabrik

Im Rahmen der W3C-XML-Schema-Unterstützung gibt es Klassen, unter anderem den Typ Duration für Dauern nach der gregorianischen Zeit. Die Klasse liegt jedoch nicht im java.util-Paket, sondern wegen ihres XML-Bezugs im Paket javax.xml.datatype (wo es neben XMLGregorianCalendar nahezu alleine liegt). Exemplare von Duration werden auch von keinem Konstruktor angelegt, sondern von einer Fabrikklasse DatatypeFactory. Beispiel: Lege ein Duration-Objekt mit der Dauer von 1 Tag und 2 Stunden an:

Duration d = DatatypeFactory.newInstance().newDuration(true, 0, 0, 1, 2, 0, 0 );
 System.out.println( d );  // P0Y0M1DT1H0M0S

Die DatatypeFactory bietet diverse Fabrikmethoden zum Anlegen der Duration-Objekte. Die Parameterlisten sind wie im Beispiel mitunter recht lang – in der längsten Variante gibt es einen Indikator für ein Vorzeichen, Jahr, Monat, Tag, Stunden, Minuten, Sekunden (keine Millisekunden oder genauer), also mit sieben Parametern. Ein Builder-Pattern zum Aufbau der Objekte wäre nett gewesen … abstract class javax.xml.datatype.DatatypeFactory

• staticDatatypeFactorynewInstance()throwsDatatypeConfigurationException
• DurationnewDuration(booleanisPositive,intyears,intmonths,intdays,inthours, intminutes,intseconds)
• abstractDurationnewDuration(booleanisPositive,BigIntegeryears,BigIntegermonths, BigIntegerdays,BigIntegerhours,BigIntegerminutes,BigDecimalseconds)
• abstractDurationnewDuration(longdurationInMilliSeconds)
• abstractDurationnewDuration(StringlexicalRepresentation)
• DurationnewDurationDayTime(booleanisPositive,BigIntegerday,BigIntegerhour,BigInteger   minute,BigIntegersecond)
• DurationnewDurationDayTime(booleanisPositive,intday,inthour,intminute,intsecond)
• DurationnewDurationDayTime(longdurationInMilliseconds)
• DurationnewDurationDayTime(StringlexicalRepresentation)
• DurationnewDurationYearMonth(booleanisPositive,BigIntegeryear,BigIntegermonth)
• DurationnewDurationYearMonth(booleanisPositive,intyear,intmonth)
• DurationnewDurationYearMonth(longdurationInMilliseconds)
• DurationnewDurationYearMonth(StringlexicalRepresentation)

Die Duration-Klasse und ihre Methoden

Die Duration-Ausgabe im Beispiel über toString() liefert eine besondere String-Repräsentation, die für XML-Dokumente interessant ist, aber andere Methoden sind interessanter. Eine grobe Einteilung ergibt:

• Anfragemethoden für die Segmente wie getYear(), getDay(), …
• Vergleichsmethoden wie compare(Duration) oder isLongerThan(Duration)
• Duration-Objekte sind immutable, doch gibt es Methoden wie add(Duration) oder multiply(Duration), die neue Duration-Objekte mit veränderten Segmenten zurückgeben, oder die Methode normalizeWith(Calendar), die Calendar-Felder zur Initialisierung nutzt.
• Anwenden der Duration-Objekte auf Calendar oder Date mit addTo(Calendar)/ addTo(Date).

Beispiel: Addiere die Dauer von 2 Monaten und 3 Tagen, und berechne, wo wir dann relativ zu heute stehen:

DatatypeFactory datatypeFactory = DatatypeFactory.newInstance();
 Duration d1 = datatypeFactory.newDurationYearMonth( true, 0, 2 );
 Duration d2 = datatypeFactory.newDuration( true, 0, 0, 3, 0, 0, 0 );
 Duration sum = d1.add( d2 );
 Date date = new Date();
 System.out.printf( "%tF%n", date ); // 2011-06-21
 sum.addTo( date );
 System.out.printf( "%tF%n", date ); // 2011-08-24

Mögliche und unmögliche Operationen

Intern speichert die Duration-Implementierung jedes einzelne Segment und legt es nicht zu einer Zahl, etwa Sekunden zusammen. Das wäre auch nicht möglich, da die Anzahl Tage im Monat und im Jahr nicht immer gleich sind (dass zeigen uns der Februar und Schaltjahre). Wenn wir auf dem 1.1. einen Monat addieren, wollen wir beim 1.2. auskommen, und wenn wir bei 1.2. beginnen und einen Monat addieren, soll der 1.3. das Ergebnis sein. Beispiel: Additionen eines Monats auf einen Kalender:

DatatypeFactory datatypeFactory = DatatypeFactory.newInstance();
 Duration month = datatypeFactory.newDurationYearMonth( true, 0, 1 );
 Calendar cal = new GregorianCalendar( 2012, Calendar.JANUARY, 1 );
 month.addTo( cal );
 System.out.printf( "%tF%n", cal); // 2012-02-01
 month.addTo( cal );
 System.out.printf( "%tF%n", cal); // 2012-03-01

Da die Anzahl der Tage im Monat und im Jahr beweglich ist, sind bei add(…) und substract(…) nur gewisse Kombinationen möglich. Es gibt Operationen, die Duration nicht ausführen kann und mit einer IllegalStateException bestraft. Während innerhalb der Gruppe Sekunden, Minuten, Stunden und Tage beliebig addiert und subtrahiert werden können, ist der Übergang nach Monat und Jahr problematisch, insbesondere bei Subtraktionen. Beispiel: 1 Monat minus 1 Tag ist genauso wenig möglich wie 1 Jahr minus 1 Tag:

DatatypeFactory factory = DatatypeFactory.newInstance();
 Duration year  = factory.newDuration( true, 1, 0, 0, 0, 0, 0 );
 Duration month = factory.newDuration( true, 0, 1, 0, 0, 0, 0 );
 Duration day   = factory.newDuration( true, 0, 0, 1, 0, 0, 0 );
 year.subtract( day );  // N  IllegalStateException
 month.subtract( day ); // N  IllegalStateException

Duration-Vergleiche

Beim Vergleichen zweier Dauern gibt es vier unterschiedliche Ergebnisse, und daher implementiert Duration auch nicht die bekannte Comparable-Schnittstelle. Der Grund ist, dass einige Vergleiche nicht endscheidbar sind. So sind 30 Tage sind nicht automatisch 1 Monat, 365 Tage nicht automatisch 1 Jahr. Die compare(…)-Methode liefert Ganzahlen, die den jeweiligen Ausgang dokumentieren:

Ausgang von Vergleichen zwischen Duration-Objekten Beispiel: Vergleiche 30 Tage mit 1 Monat:

DatatypeFactory factory = DatatypeFactory.newInstance();
 Duration month       = factory.newDurationYearMonth( true, 0, 1 );
 Duration thirtyDays  = factory.newDuration( true, 0, 0, 30, 0, 0, 0 );
 System.out.println( month.compare( thirtyDays ) ==
                     DatatypeConstants.INDETERMINATE );   // true
 System.out.println( month.isLongerThan( thirtyDays ) );  // false
 System.out.println( thirtyDays.isLongerThan( month ) );  // false

Wir sprechen bei Duration daher auch nur von einer partiellen Ordnung statt von einer vollständigen Ordnung.

Zusammenfassung der Duration-Methoden

abstract class javax.xml.datatype.DatatypeFactory

• abstractintgetSign()
• intgetYears()
• intgetMonths()
• intgetDays()
• intgetHours()
• intgetMinutes()
• intgetSeconds()
• abstractDurationadd(Durationrhs)
• Durationsubtract(Durationrhs)
• Durationmultiply(intfactor)
• abstractDurationmultiply(BigDecimalfactor)
• abstractDurationnegate()
• abstractintcompare(Durationduration)
• booleanisLongerThan(Durationduration)
• booleanisShorterThan(Durationduration)
• abstractvoidaddTo(Calendarcalendar)
• voidaddTo(Datedate)
• abstractDurationnormalizeWith(CalendarstartTimeInstant)
• longgetTimeInMillis(CalendarstartInstant)
• longgetTimeInMillis(DatestartInstant)
• abstractbooleanisSet(DatatypeConstants.Fieldfield)
• abstractNumbergetField(DatatypeConstants.Fieldfield)
• QNamegetXMLSchemaType()
• abstractinthashCode()
• booleanequals(Objectduration)
• StringtoString()

Seit dem in Java 8 die Java Date & Time API eingezogen ist, muss man nicht mehr zu diesen Typen greifen, es sei denn, mann arbeitet direkt mit der XML-API.