// #######################################################################
// ### DatenbankKern.java                                              ###
// ### Kommunikation mit der SQL-Datenbank über JDBC                   ###
// ### Verantwortlich: Thomas Dreibholz, dreibh@exp-math.uni-essen.de  ###
// #######################################################################


package puma.database;


import java.io.*;
import java.sql.*;
import java.util.*;

/*import DatenbankException;
import Liste;
import Datenobjekt;
import StringDaten;
import StringListeDaten;
import IntegerDaten;
import Einstellungen;*/


// ****** DatenbankKern **************************************************
public class DatenbankKern
{
   // *** Debug-Schalter *************************************************
   public final boolean debug    = true;
   public final boolean sqldebug = true;

   // *** Default-Werte für Verbindung zur Datenbank *********************
   public final String datenbankTreiber  = "twz1.jdbc.mysql.jdbcMysqlDriver";
   public final String datenbankURL      = "jdbc:z1MySQL://gruen.informatik.uni-bonn.de:3306/Bibliothek";
   public final String datenbankUser     = "lupo";
   public final String datenbankPasswort = "geheim";
     
   // *** Interne Variablen **********************************************
   private Connection connection;
   private Statement  statement;
   private ResultSet  result;
   
   private StringListeDaten   publikationsTypen;
   private Liste[]            datenfelder;
   private StringListeDaten   maskenTypen;
   private StringListeDaten   masken[][];   
   private Liste              instanzFelder;
   private Liste              personFelder;
   private Liste              historyFelder;
   private StringListeDaten   standardZGR;
   private StringListeDaten   statusTypen;


   
   // ###### Singleton-Pattern: Instanz erzeugen #########################
   static private DatenbankKern kernInstanz = new DatenbankKern();   
   static public DatenbankKern getInstance() {
      return(kernInstanz);
   }

   
   // ###### Liste der möglichen Publikationen holen #####################
   public StringListeDaten HolePublTypen() {
      return(publikationsTypen);
   }


   // ###### Datenfelder für angegebenen Typ holen #######################
   public Liste HolePublFelder(String typName) throws DatenbankException {
      for(int typ = 0;typ < publikationsTypen.Anzahl();typ++) {
         if(typName.equals( publikationsTypen.Element(typ) )) {
            return(datenfelder[typ]);
         }
      }
      throw new DatenbankException("Unbekannter Publikationstyp!");      
   }


   // ###### Liste der möglichen Maskentypen holen #######################
   public StringListeDaten HoleMaskenTypen() {
      return(maskenTypen);
   }


   // ###### Angegebene Maske holen ######################################
   public StringListeDaten HoleMaskenFelder(String maskeName,String typName) 
                                               throws DatenbankException {
      for(int typ = 0;typ < publikationsTypen.Anzahl();typ++) {
         if(typName.equals( publikationsTypen.Element(typ) )) {
            for(int maske = 0;maske < maskenTypen.Anzahl();maske++) {
               if(maskeName.equals( maskenTypen.Element(maske) )) {
                  return(masken[typ][maske]);
               }
            }
            throw new DatenbankException("Unbekannter Maskentyp!");            
         }
      }
      throw new DatenbankException("Unbekannter Publikationstyp!");      
   }


   // ###### Instanz-Statustypen holen ###################################
   public StringListeDaten HoleStandardZGR() {
      return(standardZGR);
   }

   
   // ###### Standard-Zugriffsrechte holen ###############################
   public StringListeDaten HoleStatusTypen() {
      return(statusTypen);
   }


   // ###### Zugriffsrechte für Benutzer holen ###########################
   synchronized public StringListeDaten HoleZGR(int benutzer) throws DatenbankException {
      try {
         // SQL-Befehl senden
         String sql = "select * from ZUGRIFFSRECHTE where PERSON_ID=" + benutzer;
         if(sqldebug) System.out.println("SQL> " + sql + ";");
         result = statement.executeQuery(sql);   

         // Ergebnis in Liste kopieren
         StringListeDaten ergebnis = new StringListeDaten("RECHTE_" + benutzer);
         while(result.next()) ergebnis.Anfuegen(result.getString("RECHT"));      
         return(ergebnis);
      } catch(SQLException e) { throw new DatenbankException("SQL: " + e); }
   }
   

   // ###### Datenfelder für Instanz holen ###############################
   public Liste HoleInstanzFelder() {
      return(instanzFelder);
   }


   // ###### Datenfelder für History holen ###############################
   public Liste HoleHistoryFelder() {
      return(historyFelder);
   }


   // ###### Datenfelder für Instanz holen ###############################
   public Liste HolePersonFelder() {
      return(personFelder);
   }


   // ###### Publikation suchen ##########################################   
   synchronized public Liste PublSuchen(Liste schluessel) throws DatenbankException {
      try {
         Liste ergebnis = new Liste();
         for(int typ = 0;typ < publikationsTypen.Anzahl();typ++) {
            Suche(publikationsTypen.Element(typ),schluessel,
                  datenfelder[typ],ergebnis);
         }      
         return(ergebnis);
      } catch(Exception e) { throw new DatenbankException("SQL: " + e); }               
   }


   // ###### Publikation suchen ##########################################   
   synchronized public Liste PublSuchenNeu(Liste schluessel, StringListeDaten ausschluss) throws DatenbankException {
      try {
         Liste ergebnis = new Liste();
         for(int typ = 0;typ < publikationsTypen.Anzahl();typ++) {
            if(!ausschluss.IstVorhanden(publikationsTypen.Element(typ))) {
               Suche(publikationsTypen.Element(typ),schluessel,
                     datenfelder[typ],ergebnis);
            }
         }      
         return(ergebnis);
      } catch(Exception e) { throw new DatenbankException("SQL: " + e); }               
   }

   
   // ###### Publikation löschen #########################################
   synchronized public void PublLoeschen(String Signatur) throws DatenbankException {
      try {
         for(int typ = 0;typ < publikationsTypen.Anzahl();typ++) {
            String sql = "delete from " + publikationsTypen.Element(typ) +
                         " where SIGNATUR='" + Signatur + "'";
            if(sqldebug) System.out.println("SQL> " + sql + ";");
            statement.executeUpdate(sql);
         }   
      } catch(SQLException e) { throw new DatenbankException("SQL: " + e); }               
   }


   // ###### Publikation hinzufügen ######################################
   synchronized public void PublHinzufuegen(Liste neu) throws DatenbankException {
      try {
         // ****** Daten mit Datenfeldliste filtern *************************
         String typ,signatur;
         try {
            typ      = neu.Suchen("TYP").Inhalt();
            signatur = neu.Suchen("SIGNATUR").Inhalt();
         } catch(NoSuchElementException e) { throw new DatenbankException("TYP oder SIGNATUR fehlt!"); }
         Liste publikation = EingabefelderFiltern(neu,HolePublFelder(typ),true);
      
         // ****** Datenbank auf Duplikate prüfen ***************************      
         if(PublSuchen(publikation).Anzahl() > 0) {
            throw new DatenbankException("Signatur existiert bereits!");
         }
      
         // ****** Publikation hinzufügen ***********************************
         InsertValues(typ,publikation);      
      } catch(Exception e) { throw new DatenbankException("SQL: " + e); }            
   }
   

   // ###### Publikation ändern ##########################################
   synchronized public void PublAendern(String signatur, Liste neu) throws DatenbankException {
      try {
         String typ;
         try {
            typ = neu.Suchen("TYP").Inhalt();
         } catch(NoSuchElementException e) { throw new DatenbankException("TYP fehlt!"); }   
         UpdateValues(typ,"SIGNATUR='" + signatur + "'",EingabefelderFiltern(neu,HolePublFelder(typ),false));
      } catch(Exception e) { throw new DatenbankException("SQL: " + e); }               
   }
   
   
   // ###### Instanz suchen ##############################################
   synchronized public Liste InstanzSuchen(String invNr) throws DatenbankException {
      try {
         // Instanz in Datenbank suchen
         String sql =
            "select * from INSTANZ where INV_NR='" + invNr + "'";
         if(sqldebug) System.out.println("SQL> " + sql + ";");
         result = statement.executeQuery(sql);   
         return(KopiereSQLErgebnisInListe(new Liste(),instanzFelder));
      } catch(SQLException e) { throw new DatenbankException("SQL: " + e); }
   }


   // ###### Instanzliste zu Publikation #################################
   synchronized public Liste InstanzenVonPubl(String signatur) throws DatenbankException {
      try {
         // Instanz in Datenbank suchen
         String sql =
            "select * from INSTANZ where SIGNATUR='" + signatur + "'";
         if(sqldebug) System.out.println("SQL> " + sql + ";");
         result = statement.executeQuery(sql);   
         return(KopiereSQLErgebnisInListe(new Liste(),instanzFelder));
      } catch(SQLException e) { throw new DatenbankException("SQL: " + e); }               
   }
              
              
   // ###### Instanz hinzufügen ##########################################
   synchronized public void InstanzHinzufuegen(Liste neu) throws DatenbankException {      
      InsertValues("INSTANZ",EingabefelderFiltern(neu,instanzFelder,true));
   }
   
   
   // ###### Instanz löschen #############################################
   synchronized public void InstanzLoeschen(String invNr) throws DatenbankException {
      try {
         String sql = "delete from INSTANZ where INV_NR='" + invNr + "'";
         if(sqldebug) System.out.println("SQL> " + sql + ";");
         statement.executeUpdate(sql);   
      } catch(SQLException e) { throw new DatenbankException("SQL: " + e); }               
   }      


   // ###### Instanz ändern ##############################################
   synchronized public void InstanzAendern(String invNr, Liste neu) throws DatenbankException {
      try {
         Liste felder = EingabefelderFiltern(neu,instanzFelder,false);

         // Parameter überprüfen      
         if(!statusTypen.IstVorhanden(felder.Suchen("STATUS").Inhalt())) {
            throw new DatenbankException("Unbekannter Statustyp: " + neu.Suchen("STATUS").Inhalt());
         }
         int personID = felder.Suchen("PERSON_ID").InhaltInteger();
         if(personID != 0) {
            if(PersonSuchen(personID).Anzahl() == 0) {
               throw new DatenbankException("Person existiert nicht: " + personID);
            }
         }
         if(InstanzSuchen(invNr).Anzahl() == 0) {
            throw new DatenbankException("Instanz existiert nicht: " + invNr);
         }                                                
      
         // Update durchführen      
         UpdateValues("INSTANZ","INV_NR='" + invNr + "'",felder);      
      } catch(Exception e) { throw new DatenbankException("SQL: " + e); }            
   }   


   // ###### Instanz ausleihen ###########################################
   synchronized public void InstanzStatusAendern(String invNr, int personID, String status) throws DatenbankException {
      // Instanz ändern
      Liste instanz = InstanzSuchen(invNr);
      instanz.Suchen("PERSON_ID").AendernInteger(personID);
      instanz.Suchen("STATUS").Aendern(status);
      InstanzAendern(invNr,instanz);

      // History ändern
      Liste history = new Liste();
      history.Anfuegen(new StringDaten("INV_NR",invNr));
      history.Anfuegen(new StringDaten("ZEITPUNKT","$NOW()"));
      history.Anfuegen(new StringDaten("STATUS",status));
      history.Anfuegen(new IntegerDaten("PERSON_ID",personID));
      HistoryHinzufuegen(history);
   }


   // ###### Person suchen ###############################################
   synchronized public Liste PersonSuchen(Liste schluessel) throws DatenbankException {
      return(Suche("PERSON",schluessel,personFelder,new Liste()));                              
   }


   // ###### Person suchen ###############################################
   synchronized public Liste PersonSuchen(int id) throws DatenbankException {
      Liste liste = new Liste();
      liste.Anfuegen(new IntegerDaten("PERSON_ID",id));
      return(PersonSuchen(liste));
   }
   
   
   // ###### Person löschen ##############################################
   synchronized public void PersonLoeschen(int id) throws DatenbankException {
      try {
         String sql = "delete from PERSON where PERSON_ID=" + id;
         if(sqldebug) System.out.println("SQL> " + sql + ";");
         statement.executeUpdate(sql);   
      } catch(SQLException e) { throw new DatenbankException("SQL: " + e); }               
   }
   

   // ###### Person ändern ###############################################
   synchronized public void PersonHinzufuegen(Liste neu) throws DatenbankException {
      InsertValues("PERSON",EingabefelderFiltern(neu,personFelder,true));
   }


   // ###### Person ändern ###############################################
   synchronized public void PersonAendern(int id, Liste neu) throws DatenbankException, Exception {
      UpdateValues("PERSON","PERSON_ID=" + id,EingabefelderFiltern(neu,personFelder,false));
   }


   // ###### Ausleihliste einer Person ###################################
   synchronized public Liste PersonAusleihliste(int id) throws DatenbankException {
      try {
         String sql =
            "select * from INSTANZ where PERSON_ID=" + id;
         if(sqldebug) System.out.println("SQL> " + sql + ";");
         result = statement.executeQuery(sql);
            return(KopiereSQLErgebnisInListe(new Liste(),instanzFelder));                  
      } catch(SQLException e) { throw new DatenbankException("SQL: " + e); }                   
   }

   
   // ###### Zugriffsrecht für Benutzer setzen ###########################
   synchronized public void SetzeZGR(int benutzer, String recht) throws DatenbankException {
      try {
         String sql = "insert into ZUGRIFFSRECHTE values(" + benutzer +
                      ",'" + recht + "')";
         if(sqldebug) System.out.println("SQL> " + sql + ";");
         statement.executeUpdate(sql);             
      } catch(SQLException e) { throw new DatenbankException("SQL: " + e); }            
   }


   // ###### Zugriffsrecht für Benutzer setzen ###########################
   synchronized public void EntzieheZGR(int benutzer, String recht) throws DatenbankException {
      try {
         String sql = "delete from ZUGRIFFSRECHTE where " +
                      "PERSON_ID=" + benutzer + " and RECHT='" + recht + "')";
         if(sqldebug) System.out.println("SQL> " + sql + ";");
         statement.executeUpdate(sql);             
      } catch(SQLException e) { throw new DatenbankException("SQL: " + e); }               
   }
   

   // ###### History suchen ##############################################
   synchronized public Liste HistorySuchen(String invNr) throws DatenbankException {      
      try {
         // History in Datenbank suchen
         String sql =
            "select * from HISTORY where INV_NR='" + invNr + "' order by ZEITPUNKT desc";
         if(sqldebug) System.out.println("SQL> " + sql + ";");
         result = statement.executeQuery(sql);   
         return(KopiereSQLErgebnisInListe(new Liste(),historyFelder));
      } catch(SQLException e) { throw new DatenbankException("SQL: " + e); }               
   }


   // ###### History-Eintrag hinzufügen ##################################
   synchronized public void HistoryHinzufuegen(Liste neu) throws DatenbankException {
      InsertValues("HISTORY",EingabefelderFiltern(neu,historyFelder,false));
   }


   // ###### History löschen #############################################
   synchronized public void HistoryLoeschen(String invNr) throws DatenbankException {
      try {
         String sql = "delete from HISTORY where " +
                      " INV_NR='" + invNr + "'";
         if(sqldebug) System.out.println("SQL> " + sql + ";");
         statement.executeUpdate(sql);   
      } catch(SQLException e) { throw new DatenbankException("SQL: " + e); }            
   }      


   // @@@@@@@@@@@@  INTERNE METHODEN  @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@

   
   // ###### Tupel aus Liste "daten" zu Relation "relation" hinzufügen ###
   protected void InsertValues(String relation, Liste daten) 
                                  throws DatenbankException {
      try {                                  
         String sql    = "insert into " + relation + "(";
         boolean komma = false;
         for(int i = 0;i < daten.Anzahl();i++) {
            if(komma == false) komma = true; else sql +=",";
            sql += daten.Element(i).Beschreibung();
         }
         sql += ") values (";
         komma = false;
         for(int i = 0;i < daten.Anzahl();i++) {
            if(komma == false) komma = true; else sql +=",";        
         
            // *** Eingebetteter SQL-Befehl, z.B. NOW() ? *******************
            boolean sqlBefehl = false;
            try {
               if(daten.Element(i).Inhalt().charAt(0) == '$') {
                  sqlBefehl = true;
               }
            } catch(Exception e) { }  
            
            // *** Wert oder Befehl einsetzen *******************************
            if(!sqlBefehl) {
               if(daten.Element(i).EingabeTyp().equals("STRING"))
                  sql += "'" + daten.Element(i).Inhalt() + "'";
               else
                  sql += daten.Element(i).Inhalt(); 
            }
            else {
               sql += daten.Element(i).Inhalt().substring(1);
            }      
         }
         sql += ")";                  
         if(sqldebug) System.out.println("SQL> " + sql + ";");
         statement.executeUpdate(sql);
      } catch(SQLException e) { throw new DatenbankException("SQL: " + e); }
   }


   // ###### Tupel aus Liste "daten" in Relation "relation" updaten ######
   protected void UpdateValues(String relation, String schluessel,
                                  Liste daten) throws DatenbankException {
      try {
         String sql    = "update " + relation + " set ";
         boolean komma = false;
         for(int i = 0;i < daten.Anzahl();i++) {
            if(komma) sql += ", ";
            komma = true;

            // *** Eingebetteter SQL-Befehl, z.B. NOW() ? *******************
            boolean sqlBefehl = false;
            try {
               if(daten.Element(i).Inhalt().charAt(0) == '$') {
                  sqlBefehl = true;
               }
            } catch(Exception e) { }  

            sql += daten.Element(i).Beschreibung() + "=";
            
            // *** Wert oder Befehl einsetzen *******************************
            if(!sqlBefehl) {
               if(daten.Element(i).EingabeTyp().equals("STRING"))
                  sql += "'" + daten.Element(i).Inhalt() + "'";
               else
                  sql += daten.Element(i).Inhalt(); 
            }
            else {
               sql += daten.Element(i).Inhalt().substring(1);
            }
         }
         sql += " where " + schluessel;
         if(sqldebug) System.out.println("SQL> " + sql + ";");
         statement.executeUpdate(sql);
      } catch(SQLException e) { throw new DatenbankException("SQL: " + e); }               
   }


   // ###### Filtern von Eingabefeldern mit Datenfeldliste ###############
   // Hierbei werden nur die Felder kopiert, die in der Liste "felder"
   // angegeben sind => Ausfilterung unzulässiger Werte
   // alleFelder = true => Alle möglichen Felder müssen in der Eingabe sein!
   protected Liste EingabefelderFiltern(Liste eingabe, Liste felder,
                                        boolean alleFelder) throws DatenbankException {
      Liste ausgabe = new Liste();
      for(int i = 0;i < felder.Anzahl();i++) {         
         String name = felder.Element(i).Beschreibung();
         try {
            ausgabe.Anfuegen(eingabe.Suchen(name));            
         } catch(NoSuchElementException e) {
            if(alleFelder) {
               throw new DatenbankException("Fehlendes Feld \"" + name + "\"!");
            }   
         }
      }
      return(ausgabe);
   }   

   
   // ###### Ergebnis einer SQL-Anfrage in Liste kopieren ################   
   // Hierbei werden die verschiedenen Typen StringDaten, IntegerDaten etc.
   // erzeugt.
   protected Liste KopiereSQLErgebnisInListe(Liste ergebnis,Liste felder) 
                                              throws SQLException {
      while(result.next()) {
         for(int feld = 0;feld < felder.Anzahl();feld++) {
            // Feld auslesen und entsprechenden Typ zu Liste hinzufügen
            String name = felder.Element(feld).Beschreibung();
            String dtyp = felder.Element(feld).EingabeTyp();
            if(dtyp.equals("STRING")) {
               ergebnis.Anfuegen(new StringDaten(name,result.getString(name)));
            }
            else if(dtyp.equals("INTEGER")) {
               ergebnis.Anfuegen(new IntegerDaten(name,result.getInt(name)));
            }
            else {
               System.err.println("Typ nicht implementiert!!!");
            }
         }
         ergebnis.Anfuegen(new StringDaten(null,null));
      }
      return(ergebnis);
   }    


   // ###### In der Datenbank suchen #####################################
   // relation = Relation, suchSchluessel = Liste mit Suchschlüsseln
   // felder = Datenfelder der Relation, ergebnis = Liste für Ergebnis
   protected Liste Suche(String relation, Liste suchSchluessel, 
                            Liste felder, Liste ergebnis) throws DatenbankException {
      try {                            
         // *** SQL-Befehl vorbereiten ***********************************
         String sql = 
            "select * from " + relation;
         boolean where = false;

         // *** Alle Felder des Schlüssels zu aktuellem Publikationstyp 
         // durchsuchen **************************************************
         for(int feld = 0;feld < suchSchluessel.Anzahl();feld++) {        
            // Schlüssel auf Datenfeld der Relation durchsuchen, WHERE-Klausel
            // ggf. erweitern
            try {
               // *** Werte in WHERE-Klausel einsetzen *******************
               String schlFeld = suchSchluessel.Element(feld).Beschreibung();
               String schlWert = suchSchluessel.Element(feld).Inhalt();
               Datenobjekt relDaten = felder.Suchen(schlFeld);
               if(where == false) {
                  sql += " where ";
                  where = true;
               }
               else {
                  sql += " and ";
               }
               // *** "like" oder "=" benutzen? **************************
               if( (schlWert.indexOf('%') != -1) ||
                   (schlWert.indexOf('_') != -1) ) {
                  sql += schlFeld + " like '" + schlWert + "'";
               }   
               else {
                  sql += schlFeld + " = '" + schlWert + "'";
               }   
            // Diese Relation besitzt diesen Schlüssel überhaupt nicht
            // -> Ende der Suche.   (z.B.: Schlüssel "UNI" in "BUCH")
            } catch(NoSuchElementException e) {
               return(ergebnis);
            }
         }
      
         // *** SQL-Befehl ausführen und Ausgabe in Liste kopieren *******
         if(sqldebug) System.out.println("SQL> " + sql + ";");
         result = statement.executeQuery(sql);
         KopiereSQLErgebnisInListe(ergebnis,felder);
         return(ergebnis);
      } catch(SQLException e) { throw new DatenbankException("SQL: " + e); }            
   }


   // @@@@@@@@@@@@  KONSTRUKTOR  @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@

   
   // ###### Konstruktor #################################################      
   private DatenbankKern() {
      // ****** JDBC-Treiber initialisieren ******************************
      Einstellungen einstellungen = Einstellungen.getInstance();
      try {
         if(debug) System.out.println("JDBC-Treiber initialisieren...");
         Class.forName(einstellungen.Wert("DatenbankKern.Treiber",datenbankTreiber));
      } catch(ClassNotFoundException e) {
         System.err.println("JDBC-Treiber nicht gefunden: " + e);
         System.exit(1);
      }
      try {      
         if(debug) System.out.println("Mit Datenbank verbinden...");
         connection = DriverManager.getConnection(
                         einstellungen.Wert("DatenbankKern.URL",datenbankURL),
                         einstellungen.Wert("DatenbankKern.User",datenbankUser),
                         einstellungen.Wert("DatenbankKern.Passwort",datenbankPasswort));
         statement  = connection.createStatement();           
      
         // ****** Publikationstypen holen **********************************
         if(debug) System.out.println("Publikationstypen holen...");
         result = statement.executeQuery("select distinct PUBL_TYP from PUBLIKATIONS_TYPEN");
         publikationsTypen = new StringListeDaten("PUBLIKATIONS_TYPEN");
         while(result.next())
            publikationsTypen.Anfuegen(result.getString("PUBL_TYP"));

         // ****** Datenfeldlisten laden ************************************
         if(debug) System.out.println("Datenfeldlisten holen...");
         instanzFelder = LadeFelder("INSTANZ_FELDER","");
         personFelder  = LadeFelder("PERSON_FELDER","");
         historyFelder  = LadeFelder("HISTORY_FELDER","");
         datenfelder   = new Liste[publikationsTypen.Anzahl()];
         for(int i = 0;i < publikationsTypen.Anzahl();i++) { 
            datenfelder[i] = LadeFelder("PUBLIKATIONS_TYPEN","where PUBL_TYP='" + publikationsTypen.Element(i) + "'");
         }   
      
         // ****** Maskentypen holen ****************************************
         if(debug) System.out.println("Maskentypen holen...");
         result = statement.executeQuery("select distinct MASKE from MASKEN");         
         maskenTypen = new StringListeDaten("MASKEN_TYPEN");
         while(result.next())
            maskenTypen.Anfuegen(result.getString("MASKE"));        

         // ****** Masken holen *********************************************
         if(debug) System.out.println("Masken holen...");
         masken = new StringListeDaten[publikationsTypen.Anzahl()][maskenTypen.Anzahl()];
         for(int i = 0;i < publikationsTypen.Anzahl();i++) {
            for(int j = 0;j < maskenTypen.Anzahl();j++) {
               result = statement.executeQuery(
                  "select SICHTBAR from MASKEN where " +
                  "PUBL_TYP='" + publikationsTypen.Element(i) + "' and " +
                  "MASKE='" + maskenTypen.Element(j) + "'"
               );
               masken[i][j] = new StringListeDaten("MASKE_" + maskenTypen.Element(j) + "_" + publikationsTypen.Element(i));
               while(result.next()) {
                  masken[i][j].Anfuegen(result.getString("SICHTBAR"));                              
               }
            }
         }

         // ****** Instanz-Statustypen holen *****************************
         if(debug) System.out.println("Statustypen holen...");
         result      = statement.executeQuery("select * from INSTANZ_STATUS_TYPEN");
         statusTypen = new StringListeDaten("INSTANZ_STATUS_TYPEN");
         while(result.next()) statusTypen.Anfuegen(result.getString("STATUS"));
            
         // ****** Standard-Zugriffsrechte holen *************************
         if(debug) System.out.println("Standard-ZGR holen...");
         result      = statement.executeQuery("select * from STANDARD_ZGR");
         standardZGR = new StringListeDaten("STANDARD_ZGR");
         while(result.next()) standardZGR.Anfuegen(result.getString("RECHT"));
         System.out.println("Ende DB-Kern-Konstruktor!");
      } catch(SQLException e) {
         System.err.println(e);
         System.exit(1);
      }
      catch(Exception E) { System.out.println("Böser Bube!!"); }
   }

   
   // # ###### Datenfeldliste für Relation laden #########################
   private Liste LadeFelder(String relation, String where) throws SQLException {
      // SQL-Befehl senden
      Liste felder = new Liste();
      String sql   = "select FELD_TYP, FELD_NAME from " + relation + " " + where;
      if(sqldebug) System.out.println("SQL> " + sql + ";");
            
      // Ergebnis in Liste kopieren
      result = statement.executeQuery(sql);
      while(result.next()) {
         felder.Anfuegen(new StringDaten(result.getString("FELD_NAME"),
                                         result.getString("FELD_TYP")));
      }                                       
      return(felder);
   }
}