Tutorial:
JavaScout ProjectAssist, Task-Frame Grundlagen (Java_Fatclient_01) –
DataBase-Access (DBA) Klasse für DB-Tabelle 'ProjLang'

In diesem Dokument wird die Klasse mit den Methoden für die Zugriffe auf die Datenbank implementiert.
Diese Klasse wird allgemein als DataBase-Access (DBA) bezeichnet und ist die unterste Ebene in der Hierarchie der Datenverwaltung.

Einen Überblick über die verschiedenen Klassen zur Verwaltung von persistenten Daten finden Sie im Dokument Business-Object – Überblick über die Funktion zum Abfragen und Speichern von Daten.
Eine detailliertere Beschreibung der Aufgabe einer DBA-Klasse finden Sie im Dokument DBA (DataBase-Access) Klasse.

Mit diesem Schritt beginnt eine 'Durststrecke' – während der Codierung der Klassen für das DBA und die Varianten des BO (Business-Object) kann keine visuelle Überprüfung der Richtigkeit des Codes erfolgen.

Aus diesem Grund wurde auch nur eine Anwendung mit wenigen GUI-Elementen, deren Werte auf der DB-Tabelle gespeichert werden müssen, gewählt

Inhaltsverzeichnis:

Voriger Schritt: Klasse für das Task-Frame zur Verwaltung von Projekt und Sprache eröffnen 

Vorbemerkung 
Vorbedingungen 
DBA-Klasse eröffnen 
Code für die DBA-Klasse 
* Von Basisklasse erben 
* Importieren der Bibliotheken 
* Definition der Namen der DB-Tabelle und der Attribute als Konstante 
* Variablen der Klasse 
* Methoden zum 'Setzen' und 'Holen' der Werte von der DB-Tabelle 
* Methoden zum Speichern und Selektieren der Daten 
Gesamter Code am Ende des Schrittes 
Klasse JS_ProjAssist_ProjeLang_DBA 
Anlegen der DB-Tabelle 
* SQL-Kommandos zum Erstellen der DB-Tabelle 
* Alternative: Einloggen in das MySQL-Datenbanksystem und Eintippen der SQL-Kommandos 
* Alternative: Ausführen einer Datei mit SQL-Kommandos 
* Alternative: Verwendung des Datenbank-Ladeprogramms 
Weitere Schritte und verwandte Dokumentation 

Nächster Schritt: General BO (Business-Object) Klasse für 'ProjectLanguage' 

Vorbemerkung

Um diesen Schritt des Tutorials zu verkürzen, wird die Methode 'delete' (die auch im Dokument DBA (DataBase-Access) Klasse als notwendige Methode gelistet ist) nicht implementiert.

Der Code für die vorgestellte Klasse erscheint vielleicht etwas über-ambitioniert für die einfache Anforderung.
Für die 'Massenproduktion' von DBA-Objekten wurde aber ein Muster-Code entwickelt, aus dem durch Ersetzen von 'Platzhaltern' einfach und vor allem schnell bedarfsgerechte DBA-Klassen implementiert werden können.
Der Muster-Code und die Anleitungen zur Adaption sind im Dokument Muster-Code für ein DBA (DataBase-Access Objekt) beschrieben.
Der in diesem Tutorial vorgestellte Code folgt der Struktur des Muster-Codes – dadurch wird das Verstehen und Adaptieren leichter.

▲ zum Inhaltsverzeichnis

Vorbedingungen:

• Voriger Schritt Klasse für das Task-Frame zur Verwaltung von Projekt und Sprache eröffnen dieses Tutorials abgeschlossen.

• Überblick über die theoretischen Grundlagen aus den Dokumenten Business-Object – Überblick über die Funktion zum Abfragen und Speichern von Daten und DBA (DataBase-Access) Klasse.

▲ zum Inhaltsverzeichnis

DBA-Klasse eröffnen

Diese Klasse wird in einem eigenen Java-Package erstellt. Das Java-Package wird bei der Erstellung der Klasse definiert.

▲ zum Inhaltsverzeichnis

Code für die DBA-Klasse

Der Code für die DBA-Klasse folgt dem Schema wie es unter DBA (DataBase-Access) Klasse > DBA-Klasse für eine bestimmte DB-Tabelle vorgestellt wurde.

Der gesamte Code ist unter Klasse JS_ProjAssist_ProjLang_DBA gelistet und mit Kommentaren versehen.
Aus diesem Grund wird anschließend der Code nicht mehr im Gesamten wiederholt sondern nur mehr Erläuterungen gegeben.

▲ zum Inhaltsverzeichnis

Von Basisklasse erben

package js_projassist.dba;
. . . . . . . .
. . . . . . . .
/*
 * Package mit der Basisklasse für ein DataBase-Access Object. */
import js_base.dba.JSBS_DBA;
. . . . . . . .
. . . . . . . .
public class JS_ProjAssist_ProjLang_DBA extends JSBS_DBA {
/*

Konstante Werte für die Namen der Common Attributes auf der DB-Tabelle, Variablen für die Common Attributes und Methoden um die Werte von und zu den Objekten, die die Verbindung zur Datenbank herstellen, zu übertragen, sind in der Basisklasse JSBS_DBA definiert.
Mit den obigen Anweisungen wird die Bibliothek, in der diese Klasse enthalten ist, importiert und von dieser Klasse 'geerbt'.

▲ zum Inhaltsverzeichnis

Importieren der Bibliotheken

package js_projassist.dba;
/*
 * Package für die Verbindung zur Datenbank. */
import java.sql.*;
/*
 * Package mit der Basisklasse für ein DataBase-Access Objekt. */
import js_base.dba.JSBS_DBA;
/* Package mit dem Minimalen Set an Parametern. Diese enthalten das Arbeitsdatum.
 * Das Arbeitsdatum wird für verschiedene Abfragen gebrauucht. */
import js_base.structures.JSBS_MinimalParameters;
/* */
public class JS_ProjAssist_ProjLang_DBA extends JSBS_DBA {
/*

Die DBA-Klasse stellt die unterste Ebene des Zugriffs auf Datenbanken dar.
Deswegen werden nur wenige Klassen aus anderen Bibliotheken verwendet.

Neben der schon beschriebenen Bibliothek mit der Basisklasse werden nur zwei weitere Bibliotheken benötigt:

• import java.sql.*;
ist die mit Java ausgelieferte Bibliothek mit den Klassen, die die Verbindung zu einem relationalen Datenbank-System herstellen.

Für die Verbindung zu einem konkret ausgewählten Datenbanksystem eines bestimmten Herstellers ist zusätzlich die von diesem Hersteller bereitgestellte Bibliothek notwendig.
Die Klassen und Methoden in dieser Hersteller-spezifischen Bibliothek wird von den Methoden in den Klassen der Bibliothek java.sql aufgerufen.
Die Hersteller-spezifische Bibliothek wurde im Schritt Einrichten von Project und Integrieren von Java-Bibliotheken > Einbindung der Libraries (Programm-Bibliotheken) in den Java Build Path eingebunden und im Schritt Weitere XML-Dateien einlesen > ConnectionManager für die Verwaltung der Verbindungen zur Datenbank konstruieren (in der Basisklasse JSBS_DB_ConnectionManager) konstruiert.

• import js_base.structures.JSBS_MinimalParameters;
enthält die Struktur mit den minimal notwendigen Parametern, die allgemeine Informationen (z.B. Name des Benutzers, gewähltes Arbeitsdatum) zwischen der Client-Applikation und den Klassen die auf der Server-Seite laufen, übertragen.
Einer dieser Parameter ist das aktuelle Arbeitsdatum und dieses ist notwendig, um die zu diesem Zeitpunkt gültigen Werte eines 'Objektes' selektieren zu können.
Eine genauere Information über die Aufzeichnung von historischen Daten und die Bedeutung des Datums finden Sie unter DBA (DataBase-Access) Klasse > Attribute zur Führung der Historie von Änderungen.

▲ zum Inhaltsverzeichnis

Definition der Namen der DB-Tabelle und der Attribute als Konstante

. . . . . . . .
. . . . . . . .
/*
 * KONSTANTE Werte für Namen der DB-Tabelle und die Attribute der DB-Tabelle.
 * ---------------------
 * Die Aufgabe der einzelnen Attribute ist unter VARIABLEN beschrieben. */
/*
 * Name der DB-Tabelle. */
    public final static String CONST_TABLE_NAME = "ProjLang";
/* Attribut für den Projekt-Code. */
    public final static String CONST_ProjectCode = "ProjectCode";
/* Attribut für den Sprach-Code. */
. . . . . . . .
. . . . . . . .

Die Definition der Namen von DB-Tabelle und deren Attribute erfolgt aus folgendem Grund:
Der Aufbau der SQL-Kommandos im Java-Programm erfolgt in Zeichenketten (Java-Klasse: String).
Tippfehler im SQL-Kommando (innerhalb des Strings) können vom Syntax-Checker des Java-Kompilers nicht erkannt werden und fallen erst auf, wenn das SQL-Kommando ausgeführt wird – also während der Laufzeit des Programms.
Um das Risiko von Tippfehlern zu verringern, werden die Namen der DB-Tabelle und deren Attribute als Konstante definiert und diese Strings dann zum passenden SQL-Kommando zusammengesetzt.

Weiters werden häufig gebrauchte Teile von SQL-Kommandos als Strings definiert.
Damit wird der Code für den Aufbau der kompletten SQL-Kommandos in den einzelnen Methoden verkürzt.

. . . . . . . .
. . . . . . . .
/*
 * KONSTANTE Werte die als Teile von SQL-Kommandos verendet werden.
 * --------------------- */
/*
 * Zeichenkette mit allen Attributen die in SELECT- und INSERT-Kommandos vorkommen.
 * Der Teil CONST_COMMON_ATTRIBUTES_LIST ist in der Basisklasse JSBS_DBA definiert. */
    final static String CONST_ALL_ATTRIBUTES_LIST =
        CONST_COMMON_ATTRIBUTES_LIST + ", " +
        CONST_ProjectCode + ", " +
        CONST_LanguageCode + ", " +
        CONST_TargetDirectory;
/*
 * Zeichenkette mit allen Attributen die in UPDATE-Kommandos vorkommen.
 * Der Teil CONST_COMMON_ATTRIBUTES_LIST_FOR_UPDATE ist in der Basisklasse JSBS_DBA definiert. */
    final static String CONST_ALL_ATTRIBUTES_LIST_FOR_UPDATE =
        "update " + CONST_TABLE_NAME + " set " +
        CONST_COMMON_ATTRIBUTES_LIST_FOR_UPDATE +
. . . . . . . .
. . . . . . . .

▲ zum Inhaltsverzeichnis

Variablen der Klasse

. . . . . . . .
. . . . . . . .
/*
 * VARIABLE dieser Klasse.
 * Diese Variablen reflektieren die Attribute der DB-Tabelle.
 * --------------------- */
/* Projekt-Code; das ist die eindeutige Identifikation für ein Projekt. */
    public String ProjectCode;
/* Sprach-Code; das ist der gewählte ISO-Sprach-Code für die sprachabhängigen Texte. */
    public String LanguageCode;
/* Namen des Ziel-Verzeichnis in dessen Unterverzeichnisse die
 * generierten XML-Dateien gespeichert werden. */
    public String TargetDirectory;
. . . . . . . .
. . . . . . . .

Die Variablen in der DBA-Klasse reflektieren die Attribute der DB-Tabelle, der die jeweilige DBA-Klasse 'zugeordnet' ist.

Nicht in diesem Beispiel gezeigt ist, daß innerhalb der DBA-Klasse auch eine eventuell notwendige Transformation zu einem Datentyp, der bei relationalen Datenbanksystemen nicht definiert ist (z.B. 'boolean' oder Enumerationen), durchgeführt wird.

▲ zum Inhaltsverzeichnis

Methoden zum 'Setzen' und 'Holen' der Werte der DB-Tabelle

Dieser Teil des Codes wird von jeder Methode zum Speichern oder Selektieren von Daten benötigt und wird in eigenen Methoden implementiert, um den Code in den aufrufenden Methoden kurz halten zu können.

. . . . . . . .
. . . . . . . .
/*
 * METHODEN */
/* ---------------------
 * METHODE zum Übertragen der Werte aus dem 'SQLResultSet' in die Variablen dieser Klasse.
 * Das 'SQLResultSet' ist eine Klasse im packaga 'java.sql' das nach einem SELECT
 * die Werte der selektierten Datensätze enthält. */
    public void getValuesFromSQLResultSet(ResultSet parmSQLResultSet)
    throws SQLException {
. . . . . . . .
. . . . . . . .
/* ---------------------
 * METHODE zum Übertragen der Werte aus den Variablen dieser Klasse in das 'PreparedStatement'.
 * Das 'PreparedStatement' ist eine Klasse im packaga 'java.sql' für ein UPDATE oder INSERT
 * das SQL-Kommando mit den neuen Werten, die auf die DB-Tabelle geschrieben werden sollen,
 * enthält. */
    public void setValuesToSQLStatement(PreparedStatement parmSQLStatement)
    throws SQLException {
/*
. . . . . . . .
. . . . . . . .

▲ zum Inhaltsverzeichnis

Methoden zum Speichern und Selektieren der Daten

Diese Methoden spiegeln die grundlegenden SQL-Kommandos zum Speichern ('insert' und 'update') und Selektieren von Daten.
Abhängig von den Anforderungen der Geschäftsfälle des Anwendungs-Programms werden weitere Methoden mit anderen Kriterien für die Selektion von Daten implementiert.

▲ zum Inhaltsverzeichnis

Gesamter Code am Ende des Schrittes

Klasse JS_ProjAssist_ProjLang_DBA

package js_projassist.dba;
/*
 * Package für die Verbindung zur Datenbank. */
import java.sql.*;
/*
 * Package mit der Basisklasse für ein DataBase-Access Objekt. */
import js_base.dba.JSBS_DBA;
/* Package mit dem Minimalen Set an Parametern. Diese enthalten das Arbeitsdatum.
 * Das Arbeitsdatum wird für verschiedene Abfragen gebrauucht. */
import js_base.structures.JSBS_MinimalParameters;
/* */
public class JS_ProjAssist_ProjLang_DBA extends JSBS_DBA {
/*
 * KONSTANTE Werte für Namen der DB-Tabelle und die Attribute der DB-Tabelle.
 * ---------------------
 * Die Aufgabe der einzelnen Attribute ist unter VARIABLEN beschrieben. */
/*
 * Name der DB-Tabelle. */
    public final static String CONST_TABLE_NAME = "ProjLang";
/* Attribut für den Projekt-Code. */
    public final static String CONST_ProjectCode = "ProjectCode";
/* Attribut für den Sprach-Code. */
    public final static String CONST_LanguageCode = "LanguageCode";
/* Attribut für das Ziel-Verzeichnis in dessen Unterverzeichnisse die
 * generierten XML-Dateien gespeichert werden. */
    public final static String CONST_TargetDirectory = "TargetDirectory";
/*
 * KONSTANTE Werte die als Teile von SQL-Kommandos verendet werden.
 * --------------------- */
/*
 * Zeichenkette mit allen Attributen die in SELECT- und INSERT-Kommandos vorkommen.
 * Der Teil CONST_COMMON_ATTRIBUTES_LIST ist in der Basisklasse JSBS_DBA definiert. */
    final static String CONST_ALL_ATTRIBUTES_LIST =
        CONST_COMMON_ATTRIBUTES_LIST + ", " +
        CONST_ProjectCode + ", " +
        CONST_LanguageCode + ", " +
        CONST_TargetDirectory;
/*
 * Zeichenkette mit allen Attributen die in UPDATE-Kommandos vorkommen.
 * Der Teil CONST_COMMON_ATTRIBUTES_LIST_FOR_UPDATE ist in der Basisklasse JSBS_DBA definiert. */
    final static String CONST_ALL_ATTRIBUTES_LIST_FOR_UPDATE =
        "update " + CONST_TABLE_NAME + " set " +
        CONST_COMMON_ATTRIBUTES_LIST_FOR_UPDATE +
        CONST_ProjectCode + " =?, " +
        CONST_LanguageCode + " =?, " +
        CONST_TargetDirectory + " =?, " +
        " where ";
/*
 * Zeichenkette mit allen Attributen und dem Namen der DB-Tabelle für ein SELECT-Kommando. */
    final static String CONST_SELECT_ALL_ATTRIBUTES =
        "select " + CONST_ALL_ATTRIBUTES_LIST +
        " from " + CONST_TABLE_NAME;
/*
 * VARIABLE dieser Klasse.
 * Diese Variablen reflektieren die Attribute der DB-Tabelle.
 * --------------------- */
/* Projekt-Code; das ist die eindeutige Identifikation für ein Projekt. */
    public String ProjectCode;
/* Sprach-Code; das ist der gewählte ISO-Sprach-Code für die sprachabhängigen Texte. */
    public String LanguageCode;
/* Namen des Ziel-Verzeichnis in dessen Unterverzeichnisse die
 * generierten XML-Dateien gespeichert werden. */
    public String TargetDirectory;
/*
 * METHODEN */
/* ---------------------
 * METHODE zum Übertragen der Werte aus dem 'SQLResultSet' in die Variablen dieser Klasse.
 * Das 'SQLResultSet' ist eine Klasse im packaga 'java.sql' das nach einem SELECT
 * die Werte der selektierten Datensätze enthält. */
    public void getValuesFromSQLResultSet(ResultSet parmSQLResultSet)
    throws SQLException {
/*
 * Aufruf der Methode der Superklasse um die 'Common Attributes' zu Übertragen. */
      try {
        getSQLResultSetForCommonAttributes(parmSQLResultSet);
      }
      catch (SQLException SQLExc) {
/* Wenn ein Fehler aufgetreten ist diesen an die aufrufende Methode zurückliefern. */
        throw SQLExc;
      }
/* Spezifische Werte für diese DBA-Klasse übertragen. */
      try {
        this.ProjectCode = parmSQLResultSet.getString(CONST_ProjectCode);
        this.LanguageCode = parmSQLResultSet.getString(CONST_LanguageCode);
        this.TargetDirectory = parmSQLResultSet.getString(CONST_TargetDirectory);
      }
/* Wenn ein Fehler aufgetreten ist diesen an die aufrufende Methode zurückliefern. */
      catch (SQLException SQLExc) {throw SQLExc;}
    }
/* ---------------------
 * METHODE zum Übertragen der Werte aus den Variablen dieser Klasse in das 'PreparedStatement'.
 * Das 'PreparedStatement' ist eine Klasse im packaga 'java.sql' für ein UPDATE oder INSERT
 * das SQL-Kommando mit den neuen Werten, die auf die DB-Tabelle geschrieben werden sollen,
 * enthält. */
    public void setValuesToSQLStatement(PreparedStatement parmSQLStatement)
    throws SQLException {
/*
 * Aufruf der Methode der Superklasse um die 'Common Attributes' zu Übertragen. */
      try {
        setSQLStatementWithCommonAttributes(parmSQLStatement);
      }
      catch (SQLException SQLExc) {
/* Wenn ein Fehler aufgetreten ist diesen an die aufrufende Methode zurückliefern. */
        throw SQLExc;
      }
/* Spezifische Werte für diese DBA-Klasse übertragen. */
      try {
        parmSQLStatement.setString(10, this.ProjectCode);
        parmSQLStatement.setString(11, this.LanguageCode);
        parmSQLStatement.setString(12, this.TargetDirectory);
      }
/* Wenn ein Fehler aufgetreten ist diesen an die aufrufende Methode zurückliefern. */
      catch (SQLException SQLExc) {throw SQLExc;}
    }
/* ---------------------
 * METHODE zum Einfügen eines neuen Datensatzes in die DB-Tabelle.
 * Voraussetzung ist, daß zuvor geprüft wurde, daß der Wert von DataSetID
 * (ein Common Attribute) noch nicht auf der DB-Tabelle existiert.
 * 'Connection' ist eine Klasse aus dem package 'java.sql' und enthält die
 * Verbindung zum Datenbanksystem. */
    public void insert(Connection parmDBCon) {
/* Aufbauen des SQL-Kommandos in einer eigenen Zeichenkette (String).
 * Gegenüber einem direkten Schreiben des des SQL-Kommandos als Parameter
 * beim 'Construct' des 'SQLStatement' hilft der eigene String beim Debuggen. */
      final String locstrSQLCommand = "insert into " + CONST_TABLE_NAME + " (" +
                                      CONST_ALL_ATTRIBUTES_LIST +
                                      ") VALUES (" +
/* 9 'Platzhalter' für die 'Common Attributes'. */
                                      "?, ?, ?, ?, ?, ?, ?, ?, ?, " +
/* 3 'Platzhalter' für die spezifischen Variablen dieser DBA-Klassen. */
                                      "?, ?, ?)";
/* 'PreparedStatement' ist eine Klasse aus dem 'java.sql'-package die das
 * SQL-Kommando an das Datenbanksystem überträgt. */
      PreparedStatement SQLStatement;
/* Es folgt die Ausführung des SQL-Kommandos; die dafür zuständigen Klassen
 * und Methoden arbeiten mit 'try/catch' zur Fehlerbehandlung. */
      try {
/* Gerade vorher definiertes 'PreparedStatement' konstruieren
 * und dabei als Parameter das SQL-Kommando übergeben. */
        SQLStatement = parmDBCon.prepareStatement(locstrSQLCommand);
/* Methode zum Übertragen der Werte aus den Variablen dieser Klasse
 * in das SQL-Kommando aufrufen. */
        setValuesToSQLStatement(SQLStatement);
/* SQL-Kommando an die Datenbank 'absenden'. */
        SQLStatement.executeUpdate();
/* SQL-Kommando wurde fehlerfrei ausgeführt; die Fehlerfreiheit wird durch eine
 * 'leere' Zeichenkette in der Variablen 'ErrorMsg' (definiert in der geerbten Basisklasse)
 * an die aufrufende Methode zurückgemeldet. */
        ErrorMsg = "";
      }
      catch (SQLException SQLExc) {
/* Wenn ein Fehler aufgetreten ist dann den Fehler-Text extrahieren und an die
 * aufrufende Methode zurückliefern. */
        ErrorMsg = SQLExc.getMessage();
      }
    }
/* ---------------------
 * METHODE zum Ändern eines bestehenden Datensatzes in der DB-Tabelle.
 * 'Connection' ist eine Klasse aus dem package 'java.sql' und enthält die
 * Verbindung zum Datenbanksystem. */
    public void update(Connection parmDBCon) {
/* Aufbauen des SQL-Kommandos in einer eigenen Zeichenkette (String).
 * Gegenüber einem direkten Schreiben des des SQL-Kommandos als Parameter
 * beim 'Construct' des 'SQLStatement' hilft der eigene String beim Debuggen. */
      final String locstrSQLCommand = CONST_ALL_ATTRIBUTES_LIST_FOR_UPDATE +
/* CONST_DataSetID ist der Primärschlüssel und in der geerbten Basisklasse
 * als 'Common Attribute' definiert. */
                                      CONST_DataSetID + " =?";
/* 'PreparedStatement' ist eine Klasse aus dem 'java.sql'-package die das
 * SQL-Kommando an das Datenbanksystem überträgt. */
      PreparedStatement SQLStatement;
/* Es folgt die Ausführung des SQL-Kommandos; die dafür zuständigen Klassen
 * und Methoden arbeiten mit 'try/catch' zur Fehlerbehandlung. */
      try {
/* Gerade vorher definiertes 'PreparedStatement' konstruieren
 * und dabei als Parameter das SQL-Kommando übergeben. */
        SQLStatement = parmDBCon.prepareStatement(locstrSQLCommand);
/* Methode zum Übertragen der Werte aus den Variablen dieser Klasse
 * in das SQL-Kommando aufrufen. */
        setValuesToSQLStatement(SQLStatement);
/* Wert für den Primärschlüssel (in der Basisklasse definiert) in die Zeichenkette
 * mit dem SQL-Kommando einfügen. */
        SQLStatement.setDouble(13, DataSetID);
/* SQL-Kommando an die Datenbank 'absenden'. */
        SQLStatement.executeUpdate();
/* SQL-Kommando wurde fehlerfrei ausgeführt; die Fehlerfreiheit wird durch eine
 * 'leere' Zeichenkette in der Variablen 'ErrorMsg' (definiert in der geerbten Basisklasse)
 * an die aufrufende Methode zurückgemeldet. */
        ErrorMsg = "";
      }
      catch (SQLException SQLExc) {
/* Wenn ein Fehler aufgetreten ist dann den Fehler-Text extrahieren und an die
 * aufrufende Methode zurückliefern. */
        ErrorMsg = SQLExc.getMessage();
      }
    }
/* ---------------------
 * METHODE zum Lesen eines Datensatzes wenn der Primärschlüssel bekannt ist.
 * Mit dem Primärschlüssel kann maximal 1 Datensatz gefunden werden.
 * Über den zurückgegeben 'boolean' Wert wird der aufrufenden Methode signalisiert,
 * ob ein Datensatz gefunden wurde.
 * 'Connection' ist eine Klasse aus dem package 'java.sql' und enthält die
 * Verbindung zum Datenbanksystem. */
    public boolean selectByDataSetID(Connection parmDBCon, double parmDataSetID) {
/* Aufbauen des SQL-Kommandos in einer eigenen Zeichenkette (String).
 * Gegenüber einem direkten Schreiben des des SQL-Kommandos als Parameter
 * beim 'Construct' des 'SQLStatement' hilft der eigene String beim Debuggen. */
      final String locstrSQLCommand = CONST_SELECT_ALL_ATTRIBUTES +
/* CONST_DataSetID ist der Primärschlüssel und wurde als Parameter übergeben. */
                                      " where " + CONST_DataSetID + " =?";
/* 'PreparedStatement' ist eine Klasse aus dem 'java.sql'-package die das
 * SQL-Kommando an das Datenbanksystem überträgt. */
      PreparedStatement SQLStatement;
/* Es folgt die Ausführung des SQL-Kommandos; die dafür zuständigen Klassen
 * und Methoden arbeiten mit 'try/catch' zur Fehlerbehandlung. */
      try {
/* Gerade vorher definiertes 'PreparedStatement' konstruieren
 * und dabei als Parameter das SQL-Kommando übergeben. */
        SQLStatement = parmDBCon.prepareStatement(locstrSQLCommand);
/* Wert für den Primärschlüssel (aus den Parametern) in die Zeichenkette
 * mit dem SQL-Kommando einfügen. */
        SQLStatement.setDouble(1, parmDataSetID);
/* SQL-Kommando an die Datenbank 'absenden'; die Werte des gefundenen Datensatzes
 * sind dann im Objekt der Klasse 'ResultSet'. */
        ResultSet SQLResultSet = SQLStatement.executeQuery();
/* 
 * Prüfen ob ein Datensatz gefunden wurde. */
        if (!SQLResultSet.next()) {
/* Kein Datensatz mit dem gesuchten Primärschlüsssel gefunden;
 * das mit dem 'boolschen Wert' an die aufrufende Methode signalisieren. */
          ErrorMsg = "";
          return false;
        }
/* Datensatz mit dem gesuchten Primärschlüsssel gefunden;
 * Methode zum Übertragen der Werte aufrufen. */
        getValuesFromSQLResultSet(SQLResultSet);
/* SQL-Kommando wurde fehlerfrei ausgeführt; die Fehlerfreiheit wird durch eine
 * 'leere' Zeichenkette in der Variablen 'ErrorMsg' (definiert in der geerbten Basisklasse)
 * an die aufrufende Methode zurückgemeldet. */
        ErrorMsg = "";
        return true;
      }
      catch (SQLException SQLExc) {
/* Wenn ein Fehler aufgetreten ist dann den Fehler-Text extrahieren und an die
 * aufrufende Methode zurückliefern. */
        ErrorMsg = SQLExc.getMessage();
/* Zusätzlich muß in dieser Methode auch ein Wert zurückgeliefert werden. */
        return false;
      }
    }
/* ---------------------
 * METHODE zum Lesen eines Datensatzes mit den Werten, die den Datensatz
 * für einen Anwender eindeutig identifizieren.
 * Mit diesen Werten und dem Arbeitsdatum (im Parameter JSBS_MinimalParameters enthalten)
 * kann maximal 1 Datensatz gefunden werden.
 * Über den zurückgegeben 'boolean' Wert wird der aufrufenden Methode signalisiert,
 * ob ein Datensatz gefunden wurde.
 * 'Connection' ist eine Klasse aus dem package 'java.sql' und enthält die
 * Verbindung zum Datenbanksystem.
 * Anmerkung zum Mandanten-ID (ClientID):
 * ----------
 * Da das Tutorial keine Möglichkeit bietet einen Mandanten zu wählen wird der Default-ClientID (Wert 0)
 * verwendet; dadurch liefert das SQL-Kommando nur einen Datensatz zurück auch wenn kein 'ClientID' im
 * 'where' enthalten ist. */
    public boolean selectByUserKnownKey(Connection parmDBCon, JSBS_MinimalParameters parmMinParm,
                                        String parmProjectCode, String parmLanguageCode) {
/* Aufbauen des SQL-Kommandos in einer eigenen Zeichenkette (String).
 * Gegenüber einem direkten Schreiben des des SQL-Kommandos als Parameter
 * beim 'Construct' des 'SQLStatement' hilft der eigene String beim Debuggen. */
      final String locstrSQLCommand = CONST_SELECT_ALL_ATTRIBUTES +
/* Selectionskriterien in die Zeichenkette einfügen. */
                                      " where " + CONST_ProjectCode + " =?" +
                                      " and " + CONST_LanguageCode + " =?" +
                                      " and " + CONST_ValidTill + " >=?" +
/* Sortierkriterium, damit eventuell in Zukunft gültige Datensätze
 * nach 'hinten' gereiht werden. */
                                      " order by " + CONST_ValidFrom + ", " +
                                      CONST_ValidTill + " desc";
/* Das im Parameter 'JSBS_MinimalParameters' enthaltene Arbeitsdatum muß in das
 * Datumsformat der 'java.sql' Klassen konvertiert werden. */
      Date locdteWorkDate = new Date(parmMinParm.calWorkDate.getTime().getTime());
/* 'PreparedStatement' ist eine Klasse aus dem 'java.sql'-package die das
 * SQL-Kommando an das Datenbanksystem überträgt. */
      PreparedStatement SQLStatement;
/* Es folgt die Ausführung des SQL-Kommandos; die dafür zuständigen Klassen
 * und Methoden arbeiten mit 'try/catch' zur Fehlerbehandlung. */
      try {
/* Gerade vorher definiertes 'PreparedStatement' konstruieren
 * und dabei als Parameter das SQL-Kommando übergeben. */
        SQLStatement = parmDBCon.prepareStatement(locstrSQLCommand);
/* Wert für die Selektions in die Zeichenkette mit dem SQL-Kommando einfügen. */
        SQLStatement.setString(1, parmProjectCode);
        SQLStatement.setString(2, parmLanguageCode);
        SQLStatement.setDate(3, locdteWorkDate);
/* SQL-Kommando an die Datenbank 'absenden'; die Werte des gefundenen Datensatzes
 * sind dann im Objekt der Klasse 'ResultSet'. */
        ResultSet SQLResultSet = SQLStatement.executeQuery();
/* 
 * Prüfen ob ein Datensatz gefunden wurde. */
        if (!SQLResultSet.next()) {
/* Kein Datensatz mit dem gesuchten Primärschlüsssel gefunden;
 * das mit dem 'boolschen Wert' an die aufrufende Methode signalisieren. */
          ErrorMsg = "";
          return false;
        }
/* Datensatz mit dem gesuchten Primärschlüsssel gefunden;
 * Methode zum Übertragen der Werte aufrufen. */
        getValuesFromSQLResultSet(SQLResultSet);
/* Prüfen ob der gefundene Datensatz mit dem größten 'ValidFrom'-Datum nicht vielleicht
 * erst in der Zukunft beginnt. */
        if (this.ValidFrom.getTime() > locdteWorkDate.getTime()) {
/* Datensatz ist erst in der Zukunft gültig; an die aufrufende Methode signalisieren,
 * daß kein Datensatz gefunden wurde. */
          ErrorMsg = "";
          return false;
        }
/* SQL-Kommando wurde fehlerfrei ausgeführt; die Fehlerfreiheit wird durch eine
 * 'leere' Zeichenkette in der Variablen 'ErrorMsg' (definiert in der geerbten Basisklasse)
 * an die aufrufende Methode zurückgemeldet. */
        ErrorMsg = "";
        return true;
      }
      catch (SQLException SQLExc) {
/* Wenn ein Fehler aufgetreten ist dann den Fehler-Text extrahieren und an die
 * aufrufende Methode zurückliefern. */
        ErrorMsg = SQLExc.getMessage();
/* Zusätzlich muß in dieser Methode auch ein Wert zurückgeliefert werden. */
        return false;
      }
    }
}

▲ zum Inhaltsverzeichnis

Anlegen der DB-Tabelle

Für das Anlegen der DB-Tabelle gibt es verschiedene Alternativen:

• Einloggen in das Datenbanksystem und Eintippen der SQL-Kommandos.
In diesem Abschnitt wird dieses Vorgehen bei einem MySQL Datenbanksystem beschrieben.

• Ausführen einer Datei mit SQL-Kommandos.
Die Beschreibung ist ebenfalls für das MySQL Datenbanksystem.

• Verwendung des Datenbank-Ladeprogramms.
Das Datenbank-Ladeprogramm mit Graphischer Benutzeroberfläche (Java_Intro_02) wird verwendet.

Bevor die Tabelle erstellt wird, sind die passenden SQL-Kommandos gelistet und es wird beschrieben, wie eine Datei mit den SQL-Kommandos erstellt wird.

▲ zum Inhaltsverzeichnis

SQL-Kommandos zum Erstellen der DB-Tabelle

Wenn zum Erstellen der DB-Tabelle eine Datei verwendet wird, muß diese Datei jetzt erstellt werden.

Die gerade erstellte Datei wird mit den folgenden SQL-Kommandos gefüllt:

CREATE TABLE ProjLang (DataSetID DOUBLE NOT NULL PRIMARY KEY);
ALTER TABLE ProjLang ADD COLUMN ClientID INTEGER NOT NULL DEFAULT 0;
ALTER TABLE ProjLang ADD COLUMN ObjectID DOUBLE NOT NULL DEFAULT 0;
ALTER TABLE ProjLang ADD COLUMN CreatedBy VARCHAR(254) NOT NULL DEFAULT '';
ALTER TABLE ProjLang ADD COLUMN CreatedAt TIMESTAMP;
ALTER TABLE ProjLang ADD COLUMN ChangedBy VARCHAR(254) NOT NULL DEFAULT '';
ALTER TABLE ProjLang ADD COLUMN ChangedAt TIMESTAMP;
ALTER TABLE ProjLang ADD COLUMN ValidFrom DATE NOT NULL DEFAULT '1999-01-01';
ALTER TABLE ProjLang ADD COLUMN ValidTill DATE NOT NULL DEFAULT '7999-12-31';
ALTER TABLE ProjLang ADD COLUMN ProjectCode CHAR(16) NOT NULL DEFAULT '';
ALTER TABLE ProjLang ADD COLUMN LanguageCode CHAR(4) NOT NULL DEFAULT '';
ALTER TABLE ProjLang ADD COLUMN TargetDirectory VARCHAR(254) NOT NULL DEFAULT '';
CREATE INDEX ProjLang_IX01 ON ProjLang (ProjectCode ASC, LanguageCode ASC, ValidTill DESC, ValidFrom ASC);

▲ zum Inhaltsverzeichnis

Alternative: Einloggen in das MySQL-Datenbanksystem und Eintippen der SQL-Kommandos

Die Anleitungen in diesem Abschnitt beziehen sich auf ein MySQL-Datenbanksystem.
Bei den Beispielen wird angenommen, daß die Datenbank mit den Parametern wie in JavaScout ProjectAssist, Start-Frame Grundlagen (Java_Fatclient_01) - Weitere XML-Strukturen einlesen > Datei mit XML-Struktur mit Parametern für die Datenbank-Verbindung erstellen erstellt wurde.

• Auf einer Kommandozeile eines 'Terminal Window' erfolgt das Einloggen in die Datenbank:
mysql –host='127.0.0.1' –user='mysql' –password='drowssap' js_tutorial

• Im Monitor von MySQL wird dann jeder SQL-Kommand eingegeben; z.B.:
CREATE TABLE ProjLang (DataSetID DOUBLE NOT NULL PRIMARY KEY);

Vergessen Sie dabei bitte nicht auf den Strichpunkt (;) am Ende eines jeden SQL-Kommandos.

• Die erfolgreiche Ausführung des Kommandos wird vom MySQL-Monitor bestätigt:
Query OK, 0 rows affected (0.03 sec)

• Wiederholen Sie die Ausführung für jedes SQL-Kommando.

▲ zum Inhaltsverzeichnis

Alternative: Ausführen einer Datei mit SQL-Kommandos

Die Anleitungen in diesem Abschnitt beziehen sich auf ein MySQL-Datenbanksystem.
Bei den Beispielen wird angenommen, daß die Datenbank mit den Parametern wie in JavaScout ProjectAssist, Start-Frame Grundlagen (Java_Fatclient_01) - Weitere XML-Strukturen einlesen > Datei mit XML-Struktur mit Parametern für die Datenbank-Verbindung erstellen erstellt wurde.

In diesem Beispiel wird angenommen, daß die Datei mit den SQL-Kommandos unter dem Namen 'Create_Tables.txt' in folgendem Verzeichnis zu finden ist:
/home/kurti-o/java_fatclient/Java_Fatclient_01/DB_Scripts

Der Teil /kurti-o/ des Verzeichnisses wird bei Ihnen sicher nicht stimmen und muß entsprechend Ihrem Benutzernamen angepaßt werden.

• Auf einer Kommandozeile eines 'Terminal Window' erfolgt das Einloggen in die Datenbank:
mysql –host='127.0.0.1' –user='mysql' –password='drowssap' js_tutorial

• Im Monitor von MySQL wird das Ausführen der Datei mit den SQL-Kommandos mit folgendem Befehl gestartet:
source /home/kurti-o/java_fatclient/Java_Fatclient_01/DB_Scripts/Create_Tables.txt;

Vergessen Sie dabei bitte nicht auf den Strichpunkt (;) am Ende eines jeden SQL-Kommandos.

• Die erfolgreiche Ausführung des Kommandos wird vom MySQL-Monitor bestätigt.
Für das Kommando CREATE TABLE ProjLang (.... erfolgt diese Rückmeldung:
Query OK, 0 rows affected (0.70 sec)

Für jedes folgende Kommando erfolgt diese Rückmeldung:
Query OK, 0 rows affected (0.70 sec)
Records: 0 Duplicates: 0 Warnings: 0

Prüfen Sie bitte, daß jedes Kommando (jede Zeile aus der Datei) ohne Fehlermeldung ausgeführt wurde.

▲ zum Inhaltsverzeichnis

Alternative: Verwendung des Datenbank-Ladeprogramms

Als weitere Alternative kann das im Einführungs-Tutorial erstellte Ladeprogramm für eine Datenbank-Tabelle verwendet werden.

Dazu muß im Verzeichnis 'DB_Scripts' eine Datei mit den Parametern für die Verbindung zur Datenbank erstellt werden.
Der Aufbau der Datei ist unter Datenbank-Ladeprogramm mit Graphischer Benutzeroberfläche (Java_Intro_02) - XML-Struktur lesen > Verzeichnis und Datei mit XML-Struktur erstellen beschrieben.

Die Ausführung des Programms ist unter Datenbank-Ladeprogramm mit Graphischer Benutzeroberfläche (Java_Intro_02) - SQL-Kommandos ausführen > Test beschrieben.

▲ zum Inhaltsverzeichnis

Weitere Schritte und verwandte Dokumentation

▲ zum Inhaltsverzeichnis