package polarisserverlogik;

  /* automatisch von ER2SQL 3.38 erzeugte Unit fuer JDBC.
   *  Erzeugungsdatum : Sat Jan 31 23:34:54 2004

   *  Zieldatenbank: POLARIS
   *  Fuer die Virtabs wird ein Nachfahre von java.sql.ResultSet definiert: VirtabPOLARIS_ResultSet
   *  !!! Erster Versuch!!!
   */

import oracle.jdbc.*;


/* Diese Packages nur, weil sie von ResultSet benutzt werden */
import java.io.*;

import java.math.*;

import java.sql.*;

import java.util.*;


public class VirtabPolaris_ResultSet implements ResultSet
{
    //~ Static fields/initializers -------------------------------------------------------------------------------------------------

    /*
     * Ein eigenes ResultSet, das Insert, Update, Delete auf
     * Virtab-Updatable-Views erlaubt.
     * Primitiv-Implementierung, bis mehr Zeit/erfahrung da ist ...
     *
     * Änderungen gegenüber ResultSet:
     * - Im Constructor muss <virtabkind>, <Vorgänger-resultset> übergeben werden.
     * - Parameter werden mit updateString(), etc ... fürs Setzen gemerkt
     *   Zum Merken dient ein Zeilenpuffer "recordbuffer"
     *  insertRow() ruft die Insert-stored-procedure auf
     *  updateRow()  ruft die Update-stored-procedure auf
     *  deleteRow() ruft die Delete-stored-procedure auf
     *  - moveToInsertRow() setzt ein Flag "in_insert"
     *
     *    Einschränkungen unter anderem:
     *    - Es sind nur getXxx und updateXxx für die Basistypen implemnetiert.
     *    - Es sind nur getXxx(columnName) und updateXxx(columnName) implemnetiert.
     *    - Aufruf Sequenz für Update MUSS sein:
     *       updateString(), ... updateString(), updateRow()
     *    - Aufruf Sequenz für Update MUSS sein:
     *      moveToInsertRow(),  updateString(), ... updateString(), insertRow()
     *    - der neue PK nach "insertRow()" ist nicht ermittelbar (wie nützlich ....)
     *    - updateRow() bzw. insertRow() MUESSEN kommen, nur sie loeschen die
     *      Feld und Wertlisten für den nächsten Aufruf!
     *
     *      Revisionhistory:
     *      10.9.2003:  Jörg
     *                  - die getXxx() lesen aus demselben Puffer, in den updateXxx() geschrieben hat.
     *                  - Puffer ist eine ArrayList mit ElementTyp "FieldValue"
     *                  - float, double, byte, short, int, long werden intern als "BigDecimal" gespeichert.
     *                  - für jeden Feldtyp kann getString() gemacht werden,
     *                    alle  numericals können gemischt werden.
     *                    aber getFloat() auf einen String, der "123" enthält, geht nicht.
     *
     *                  - ziemlich ungetestet!
     *
     */

    // Codes für Typen der Virtabprozeduren
    public static final int vtproctypeInsert = 1;
    public static final int vtproctypeUpdate = 2;
    public static final int vtproctypeDelete = 3;

    // virtabType
    public static final int vtkNone = 0;
    public static final int vtkSALES = 1;
    public static final int vtkDEPTS = 2;
    public static final int vtkDEPTS_2 = 3;
    public static final int vtkDEPTS_3 = 4;
    public static final int vtkDEPTS_4 = 5;
    public static final int vtkDEPTS_5 = 6;
    public static final int vtkDEPTS_6 = 7;
    public static final int vtkletter_data = 8;
    public static final int vtkletter_data_emp = 9;
    public static final int vtkletter_data_cust = 10;
    public static final int vtkletter_data_main = 11;
    public static final int vtkHIERARCHY = 12;
    public static final int vtkDEPTSINFO = 13;
    public static final int vtkDEPTSINFO1 = 14;

    //~ Instance fields ------------------------------------------------------------------------------------------------------------

    ArrayList           recordbuffer              = new ArrayList(200); // Enthaelt nur FieldValue: Liste der name = <val>-Paare
    ArrayList           recordbuffer_tmp          = new ArrayList(200); // Hilfsliste für recordbuffer_assertvtfield()
    ResultSet           super_rs; // das originale Resultset, das hier funktional erweitert wird.
    CallableStatement[] vt_proc                   = { null, null, null, null };
    boolean             in_insert                 = false; // true nach "moveToInsertRow()"
    boolean             recordbuffer_sortedbyname = false; // true = recordbuffer ist nach fieldname sortiert.
    int                 virtabkind; // wie im Constructor uebergeben

    //~ Constructors ---------------------------------------------------------------------------------------------------------------

    public VirtabPolaris_ResultSet(int p_virtabkind, ResultSet p_super_rs)
    {
        virtabkind                    = p_virtabkind;
        super_rs                      = p_super_rs;
        recordbuffer_sortedbyname     = false;
    }

    //~ Methods --------------------------------------------------------------------------------------------------------------------

    public static void main(String[] args)
    {
        // Testcode.
        try {
            String     bw_fields = "OBJ_ID,BETRIEB,VORNAME,NACHNAME,BEARBEITER";
            String     querysql = "SELECT * FROM VT_BEWIRTSCHAFTER  WHERE betrieb like 'Tre%' ORDER BY betrieb";

            Connection conn = Basis.getConnection("PLR_EXP4", "DB_SYS", "DB_SYS");
            conn.setAutoCommit(false); // beginne Transaktion

            // Dieses Resultset muss es sein
            VirtabPolaris_ResultSet vt_rs = new VirtabPolaris_ResultSet(
                    VirtabPolaris_ResultSet.vtkBewirtschafter, conn.createStatement().executeQuery(querysql));
            vt_rs.next();

            System.out.println("#### Scanne Bewirtschafter mit 'Tre*', füge 'Treteimer' ein");
            Basis.printRecord(vt_rs, "1. Datensatz", "vt_bewirtschafter", bw_fields, true);
            // Bauer einfügen
            vt_rs.moveToInsertRow();
            vt_rs.updateString("BETRIEB", "Treteimer GbR");
            vt_rs.updateString("VORNAME", "Theodor");
            vt_rs.updateString("NACHNAME", "Treteimer");
            vt_rs.updateString("BEARBEITER", "JOERG");
            Basis.printRecord(vt_rs, "Neuer Datensatz, vor Insert", "vt_bewirtschafter", bw_fields, true);
            vt_rs.insertRow();
            Basis.printRecord(vt_rs, "Neuer Datensatz, nach Insert (OBJ_ID!)", "vt_bewirtschafter", bw_fields, true);

            while (vt_rs.next())
                Basis.printRecord(vt_rs, "2. Rest der Abfrage, ignorieren insert ", "vt_bewirtschafter", bw_fields, true);
            vt_rs.getStatement().close();

            //////////////////////////////////////////////////
            // Nochmal neu: liefert Datensatz
            System.out.println("#### Datenmenge neu lesen,  Treteimer muss dabei sein");
            vt_rs = new VirtabPolaris_ResultSet(VirtabPolaris_ResultSet.vtkBewirtschafter, conn.createStatement().executeQuery(querysql));
            while (vt_rs.next())
                Basis.printRecord(vt_rs, "3. Reopen: neuer Datensatz jetzt da", "vt_bewirtschafter", bw_fields, true);
            vt_rs.getStatement().close();

            //////////////////////////////////////////////////
            // Nochmal neu:  und bei "Treteimer" den Vornamen ändern
            System.out.println("#### Datenmenge neu lesen und bei Treteimer den Vornamen ändern");
            vt_rs = new VirtabPolaris_ResultSet(VirtabPolaris_ResultSet.vtkBewirtschafter, conn.createStatement().executeQuery(querysql));
            while (vt_rs.next()) {
                Basis.printRecord(vt_rs, "4. Reopen: ...", "vt_bewirtschafter", bw_fields, true);
                if (vt_rs.getString("NACHNAME").equalsIgnoreCase("Treteimer")) {
                    vt_rs.updateString("VORNAME", "Thomas");
                    vt_rs.updateRow();
                    Basis.printRecord(vt_rs, "5. Vorname von Treteimer geändert!", "vt_bewirtschafter", bw_fields, true);
                }
            }
            vt_rs.getStatement().close();

            //////////////////////////////////////////////////
            System.out.println("#### Datenmenge neu lesen: liefert Datensatz mit 'Thomas Treteimer'");
            vt_rs = new VirtabPolaris_ResultSet(VirtabPolaris_ResultSet.vtkBewirtschafter, conn.createStatement().executeQuery(querysql));
            while (vt_rs.next())
                Basis.printRecord(vt_rs, "6. Scan ...", "vt_bewirtschafter", bw_fields, true);
            vt_rs.getStatement().close();

            System.out.println("#### Datenmenge neu lesen, und Thomas Treteimer löschen");
            vt_rs = new VirtabPolaris_ResultSet(VirtabPolaris_ResultSet.vtkBewirtschafter, conn.createStatement().executeQuery(querysql));
            while (vt_rs.next()) {
                Basis.printRecord(vt_rs, "7. Scan for delete ...", "vt_bewirtschafter", bw_fields, true);
                if (vt_rs.getString("NACHNAME").equalsIgnoreCase("Treteimer")) {
                    vt_rs.deleteRow();
                    Basis.printRecord(
                        vt_rs, "8.  Treteimer in DB gelöscht, hier noch sichtbar?", "vt_bewirtschafter", bw_fields, true);
                }
            }
            vt_rs.getStatement().close();

            System.out.println("#### Ein letztes Mal Datenmenge neu lesen: wieder ohne 'Treteimer'");
            vt_rs = new VirtabPolaris_ResultSet(VirtabPolaris_ResultSet.vtkBewirtschafter, conn.createStatement().executeQuery(querysql));
            while (vt_rs.next())
                Basis.printRecord(vt_rs, "9. Scan ...", "vt_bewirtschafter", bw_fields, true);
            vt_rs.getStatement().close();

            conn.rollback();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    public boolean isAfterLast() throws SQLException
    {
        return super_rs.isAfterLast();
    }


    public Array getArray(int i) throws SQLException
    {
        return super_rs.getArray(i);
    }


    public Array getArray(String colName) throws SQLException
    {
        return super_rs.getArray(colName);
    }


    public InputStream getAsciiStream(int columnIndex)
        throws SQLException
    {
        return super_rs.getAsciiStream(columnIndex);
    }


    public InputStream getAsciiStream(String columnName)
        throws SQLException
    {
        return super_rs.getAsciiStream(columnName);
    }


    public boolean isBeforeFirst() throws SQLException
    {
        return super_rs.isBeforeFirst();
    }


    public BigDecimal getBigDecimal(int columnIndex) throws SQLException
    {
        return super_rs.getBigDecimal(columnIndex);
    }


    public BigDecimal getBigDecimal(int columnIndex, int scale)
        throws SQLException
    {
        return super_rs.getBigDecimal(columnIndex, scale);
    }


    public BigDecimal getBigDecimal(String columnName)
        throws SQLException
    {
        return super_rs.getBigDecimal(columnName);
    }


    public BigDecimal getBigDecimal(String columnName, int scale)
        throws SQLException
    {
        return super_rs.getBigDecimal(columnName, scale);
    }


    public InputStream getBinaryStream(int columnIndex)
        throws SQLException
    {
        return super_rs.getBinaryStream(columnIndex);
    }


    public InputStream getBinaryStream(String columnName)
        throws SQLException
    {
        return super_rs.getBinaryStream(columnName);
    }


    public Blob getBlob(int i) throws SQLException
    {
        return super_rs.getBlob(i);
    }


    public Blob getBlob(String colName) throws SQLException
    {
        return super_rs.getBlob(colName);
    }


    public boolean getBoolean(int columnIndex) throws SQLException
    {
        return super_rs.getBoolean(columnIndex);
    }


    public boolean getBoolean(String columnName) throws SQLException
    {
        // return super_rs.getBoolean(columnName);
        return ((Boolean) recordbuffer_getfieldvalue(columnName)).booleanValue();
    }


    public byte getByte(int columnIndex) throws SQLException
    {
        return super_rs.getByte(columnIndex);
    }


    public byte getByte(String columnName) throws SQLException
    {
        // return super_rs.getByte(columnName);
        Object o = recordbuffer_getfieldvalue(columnName);
        return (o == null) ? 0 : ((BigDecimal) o).byteValue();
    }


    public byte[] getBytes(int columnIndex) throws SQLException
    {
        return super_rs.getBytes(columnIndex);
    }


    public byte[] getBytes(String columnName) throws SQLException
    {
        return super_rs.getBytes(columnName);
    }


    public Reader getCharacterStream(int columnIndex) throws SQLException
    {
        return super_rs.getCharacterStream(columnIndex);
    }


    public Reader getCharacterStream(String columnName)
        throws SQLException
    {
        return super_rs.getCharacterStream(columnName);
    }


    public Clob getClob(int i) throws SQLException
    {
        return super_rs.getClob(i);
    }


    public Clob getClob(String colName) throws SQLException
    {
        return super_rs.getClob(colName);
    }


    public int getConcurrency() throws SQLException
    {
        return super_rs.getConcurrency();
    }


    public String getCursorName() throws SQLException
    {
        return super_rs.getCursorName();
    }


    public java.sql.Date getDate(int columnIndex) throws SQLException
    {
        return super_rs.getDate(columnIndex);
    }


    public java.sql.Date getDate(int columnIndex, Calendar cal)
        throws SQLException
    {
        return super_rs.getDate(columnIndex, cal);
    }


    public java.sql.Date getDate(String columnName) throws SQLException
    {
        //return super_rs.getDate(columnName);
        return ((java.sql.Date) recordbuffer_getfieldvalue(columnName));
    }


    public java.sql.Date getDate(String columnName, Calendar cal)
        throws SQLException
    {
        return super_rs.getDate(columnName, cal);
    }


    public double getDouble(int columnIndex) throws SQLException
    {
        return super_rs.getDouble(columnIndex);
    }


    public double getDouble(String columnName) throws SQLException
    {
        // return super_rs.getDouble(columnName);
        Object o = recordbuffer_getfieldvalue(columnName);
        return (o == null) ? 0 : ((BigDecimal) o).doubleValue();
    }


    public void setFetchDirection(int direction) throws SQLException
    {
        super_rs.setFetchDirection(direction);
    }


    public int getFetchDirection() throws SQLException
    {
        return super_rs.getFetchDirection();
    }


    public void setFetchSize(int rows) throws SQLException
    {
        super_rs.setFetchSize(rows);
    }


    public int getFetchSize() throws SQLException
    {
        return super_rs.getFetchSize();
    }


    public boolean isFirst() throws SQLException
    {
        return super_rs.isFirst();
    }


    public float getFloat(int columnIndex) throws SQLException
    {
        return super_rs.getFloat(columnIndex);
    }


    public float getFloat(String columnName) throws SQLException
    {
        // return super_rs.getFloat(columnName);
        Object o = recordbuffer_getfieldvalue(columnName);
        return (o == null) ? 0 : ((BigDecimal) o).floatValue();
    }


    public int getInt(int columnIndex) throws SQLException
    {
        return super_rs.getInt(columnIndex);
    }


    public int getInt(String columnName) throws SQLException
    {
        // return super_rs.getInt(columnName);
        Object o = recordbuffer_getfieldvalue(columnName);
        return (o == null) ? 0 : ((BigDecimal) o).intValue();
    }


    public boolean isLast() throws SQLException
    {
        return super_rs.isLast();
    }


    public long getLong(int columnIndex) throws SQLException
    {
        return super_rs.getLong(columnIndex);
    }


    public long getLong(String columnName) throws SQLException
    {
        //return super_rs.getLong(columnName);
        Object o = recordbuffer_getfieldvalue(columnName);
        return (o == null) ? 0 : ((BigDecimal) o).longValue();
    }


    public ResultSetMetaData getMetaData() throws SQLException
    {
        return super_rs.getMetaData();
    }


    // neu + nützlich
    public boolean isNull(int columnIndex) throws SQLException
    {
        super_rs.getObject(columnIndex); // Testabfrage

        return super_rs.wasNull();
    }


    public boolean isNull(String columnName) throws SQLException
    {
        int i = super_rs.findColumn(columnName);
        super_rs.getObject(i); // Testabfrage

        return super_rs.wasNull();
    }


    public Object getObject(int columnIndex) throws SQLException
    {
        return super_rs.getObject(columnIndex);
    }


    public Object getObject(int i, Map map) throws SQLException
    {
        return super_rs.getObject(i, map);
    }


    public Object getObject(String columnName) throws SQLException
    {
        // return super_rs.getObject(columnName);
        return recordbuffer_getfieldvalue(columnName);
    }


    public Object getObject(String colName, Map map) throws SQLException
    {
        return super_rs.getObject(colName, map);
    }


    public Ref getRef(int i) throws SQLException
    {
        return super_rs.getRef(i);
    }


    public Ref getRef(String colName) throws SQLException
    {
        return super_rs.getRef(colName);
    }


    public int getRow() throws SQLException
    {
        return super_rs.getRow();
    }


    public short getShort(int columnIndex) throws SQLException
    {
        return super_rs.getShort(columnIndex);
    }


    public short getShort(String columnName) throws SQLException
    {
        //return super_rs.getShort(columnName);
        Object o = recordbuffer_getfieldvalue(columnName);
        return (o == null) ? 0 : ((BigDecimal) o).shortValue();
    }


    public Statement getStatement() throws SQLException
    {
        return super_rs.getStatement();
    }


    public String getString(int columnIndex) throws SQLException
    {
        return super_rs.getString(columnIndex);
    }


    public String getString(String columnName) throws SQLException
    {
        //return super_rs.getString(columnName);
        Object o = recordbuffer_getfieldvalue(columnName);
        return (o == null) ? "" : o.toString();
    }


    public Time getTime(int columnIndex) throws SQLException
    {
        return super_rs.getTime(columnIndex);
    }


    public Time getTime(int columnIndex, Calendar cal)
        throws SQLException
    {
        return super_rs.getTime(columnIndex, cal);
    }


    public Time getTime(String columnName) throws SQLException
    {
        // return super_rs.getTime(columnName);
        return ((Time) recordbuffer_getfieldvalue(columnName));
    }


    public Time getTime(String columnName, Calendar cal)
        throws SQLException
    {
        return super_rs.getTime(columnName, cal);
    }


    public Timestamp getTimestamp(int columnIndex) throws SQLException
    {
        return super_rs.getTimestamp(columnIndex);
    }


    public Timestamp getTimestamp(int columnIndex, Calendar cal)
        throws SQLException
    {
        return super_rs.getTimestamp(columnIndex, cal);
    }


    public Timestamp getTimestamp(String columnName) throws SQLException
    {
        // return super_rs.getTimestamp(columnName);
        return ((Timestamp) recordbuffer_getfieldvalue(columnName));
    }


    public Timestamp getTimestamp(String columnName, Calendar cal)
        throws SQLException
    {
        return super_rs.getTimestamp(columnName, cal);
    }


    public int getType() throws SQLException
    {
        return super_rs.getType();
    }


    public InputStream getUnicodeStream(int columnIndex)
        throws SQLException
    {
        return super_rs.getUnicodeStream(columnIndex);
    }


    public InputStream getUnicodeStream(String columnName)
        throws SQLException
    {
        return super_rs.getUnicodeStream(columnName);
    }


    public SQLWarning getWarnings() throws SQLException
    {
        return super_rs.getWarnings();
    }


    /* beinahe alle Methoden kommen aus dem übergebenen ResultSet
     * Geht das hier nicht einfacher?
     * */
    public boolean absolute(int row) throws SQLException
    {
        return super_rs.absolute(row);
    }


    public void afterLast() throws SQLException
    {
        super_rs.afterLast();
    }


    public void beforeFirst() throws SQLException
    {
        super_rs.beforeFirst();
    }


    public void cancelRowUpdates() throws SQLException
    {
        super_rs.cancelRowUpdates();
    }


    public void clearWarnings() throws SQLException
    {
        super_rs.clearWarnings();
    }


    public void close() throws SQLException
    {
        super_rs.close();
    }


    public void deleteRow() throws SQLException
    {
        // super_rs.deleteRow();
        in_insert = false;
        recordbuffer.clear();
        vt_callProc(vtproctypeDelete, virtabkind);
        // recordbuffer enthält jetzt die neuen Ergebnisse
        recordbuffer.clear();
    }


    public int findColumn(String columnName) throws SQLException
    {
        return super_rs.findColumn(columnName);
    }


    public boolean first() throws SQLException
    {
        in_insert = false;
        recordbuffer.clear();
        return super_rs.first();
    }


    public void insertRow() throws SQLException
    { // siehe auch "updateRow()"
        //        super_rs.insertRow();
        vt_callProc(vtproctypeInsert, virtabkind);
        // recordbuffer enthält jetzt die neuen Ergebnisse
    }


    public boolean last() throws SQLException
    {
        in_insert = false;
        recordbuffer.clear();
        return super_rs.last();
    }


    public void moveToCurrentRow() throws SQLException
    {
        super_rs.moveToCurrentRow();
        in_insert = false;
        recordbuffer.clear();
    }


    public void moveToInsertRow() throws SQLException
    {
        //super_rs.moveToInsertRow();
        // macht gar nix.
        recordbuffer.clear();
        in_insert = true;
    }


    public boolean next() throws SQLException
    {
        in_insert = false;
        recordbuffer.clear();
        return super_rs.next();
    }


    public boolean previous() throws SQLException
    {
        in_insert = false;
        recordbuffer.clear();
        return super_rs.previous();
    }


    public void refreshRow() throws SQLException
    {
        super_rs.refreshRow();
        recordbuffer.clear();
    }


    public boolean relative(int rows) throws SQLException
    {
        return super_rs.relative(rows);
    }


    public boolean rowDeleted() throws SQLException
    {
        return super_rs.rowDeleted();
    }


    public boolean rowInserted() throws SQLException
    {
        return super_rs.rowInserted();
    }


    public boolean rowUpdated() throws SQLException
    {
        return super_rs.rowUpdated();
    }


    public void updateAsciiStream(int columnIndex, InputStream x, int length)
        throws SQLException
    {
        super_rs.updateAsciiStream(columnIndex, x, length);
    }


    public void updateAsciiStream(String columnName, InputStream x, int length)
        throws SQLException
    {
        super_rs.updateAsciiStream(columnName, x, length);
    }


    public void updateBigDecimal(int columnIndex, BigDecimal x)
        throws SQLException
    {
        super_rs.updateBigDecimal(columnIndex, x);
    }


    public void updateBigDecimal(String columnName, BigDecimal x)
        throws SQLException
    {
        super_rs.updateBigDecimal(columnName, x);
    }


    public void updateBinaryStream(int columnIndex, InputStream x, int length)
        throws SQLException
    {
        super_rs.updateBinaryStream(columnIndex, x, length);
    }


    public void updateBinaryStream(String columnName, InputStream x, int length)
        throws SQLException
    {
        super_rs.updateBinaryStream(columnName, x, length);
    }


    public void updateBoolean(int columnIndex, boolean x)
        throws SQLException
    {
        super_rs.updateBoolean(columnIndex, x);
    }


    public void updateBoolean(String columnName, boolean x)
        throws SQLException
    {
        super_rs.updateBoolean(columnName, x);
    }


    public void updateByte(int columnIndex, byte x) throws SQLException
    {
        super_rs.updateByte(columnIndex, x);
    }


    public void updateByte(String columnName, byte x) throws SQLException
    {
        // super_rs.updateByte(columnName, x);
        recordbuffer_setfieldvalue(columnName, new BigDecimal(x));
    }


    public void updateBytes(int columnIndex, byte[] x)
        throws SQLException
    {
        super_rs.updateBytes(columnIndex, x);
    }


    public void updateBytes(String columnName, byte[] x)
        throws SQLException
    {
        super_rs.updateBytes(columnName, x);
    }


    public void updateCharacterStream(int columnIndex, Reader x, int length)
        throws SQLException
    {
        super_rs.updateCharacterStream(columnIndex, x, length);
    }


    public void updateCharacterStream(String columnName, Reader reader, int length)
        throws SQLException
    {
        super_rs.updateCharacterStream(columnName, reader, length);
    }


    public void updateDate(int columnIndex, java.sql.Date x)
        throws SQLException
    {
        super_rs.updateDate(columnIndex, x);
    }


    /* überschrieben */
    public void updateDate(String columnName, java.sql.Date x)
        throws SQLException
    {
        // super_rs.updateDate(columnName, x);
        recordbuffer_setfieldvalue(columnName, new java.sql.Date(x.getTime()));
    }


    public void updateDouble(int columnIndex, double x)
        throws SQLException
    {
        super_rs.updateDouble(columnIndex, x);
    }


    /* überschrieben */
    public void updateDouble(String columnName, double x)
        throws SQLException
    {
        // super_rs.updateDouble(columnName, x);
        recordbuffer_setfieldvalue(columnName, new BigDecimal(x));
        //recordbuffer_setfieldvalue(columnName, new Double(x));
    }


    public void updateFloat(int columnIndex, float x) throws SQLException
    {
        super_rs.updateFloat(columnIndex, x);
    }


    /* überschrieben */
    public void updateFloat(String columnName, float x)
        throws SQLException
    {
        // super_rs.updateFloat(columnName, x);
        recordbuffer_setfieldvalue(columnName, new BigDecimal(x));
    }


    public void updateInt(int columnIndex, int x) throws SQLException
    {
        super_rs.updateInt(columnIndex, x);
    }


    public void updateInt(String columnName, int x) throws SQLException
    {
        // super_rs.updateInt(columnName, x);
        recordbuffer_setfieldvalue(columnName, new BigDecimal(x));
    }


    public void updateLong(int columnIndex, long x) throws SQLException
    {
        super_rs.updateLong(columnIndex, x);
    }


    /* überschrieben */
    public void updateLong(String columnName, long x) throws SQLException
    {
        super_rs.updateLong(columnName, x);
        recordbuffer_setfieldvalue(columnName, new BigDecimal(x));
    }


    public void updateNull(int columnIndex) throws SQLException
    {
        super_rs.updateNull(columnIndex);
    }


    /* überschrieben */
    public void updateNull(String columnName) throws SQLException
    {
        // super_rs.updateNull(columnName);
        recordbuffer_setfieldvalue(columnName, null);
    }


    public void updateObject(int columnIndex, Object x)
        throws SQLException
    {
        super_rs.updateObject(columnIndex, x);
    }


    public void updateObject(int columnIndex, Object x, int scale)
        throws SQLException
    {
        super_rs.updateObject(columnIndex, x, scale);
    }


    public void updateObject(String columnName, Object x)
        throws SQLException
    {
        super_rs.updateObject(columnName, x);
    }


    public void updateObject(String columnName, Object x, int scale)
        throws SQLException
    {
        super_rs.updateObject(columnName, x, scale);
    }


    public void updateRow() throws SQLException
    {
        vt_callProc(vtproctypeUpdate, virtabkind);
        // recordbuffer enthält jetzt die neuen Ergebnisse
    }


    /* ueberschrieben!
       public void updateRow() throws SQLException {
           super_rs.updateRow();
       }
     */
    public void updateShort(int columnIndex, short x) throws SQLException
    {
        super_rs.updateShort(columnIndex, x);
    }


    public void updateShort(String columnName, short x)
        throws SQLException
    {
        // super_rs.updateShort(columnName, x);
        recordbuffer_setfieldvalue(columnName, new BigDecimal(x));
    }


    public void updateString(int columnIndex, String x)
        throws SQLException
    {
        super_rs.updateString(columnIndex, x);
    }


    /* ueberschrieben! */
    public void updateString(String columnName, String x)
        throws SQLException
    {
        // super_rs.updateString(columnName, x);
        recordbuffer_setfieldvalue(columnName, x);
    }


    public void updateTime(int columnIndex, Time x) throws SQLException
    {
        super_rs.updateTime(columnIndex, x);
    }


    /* ueberschrieben! */
    public void updateTime(String columnName, Time x) throws SQLException
    {
        // super_rs.updateTime(columnName, x);
        recordbuffer_setfieldvalue(columnName, new Time(x.getTime()));
    }


    public void updateTimestamp(int columnIndex, Timestamp x)
        throws SQLException
    {
        super_rs.updateTimestamp(columnIndex, x);
    }


    /* überschrieben */
    public void updateTimestamp(String columnName, Timestamp x)
        throws SQLException
    {
        // super_rs.updateTimestamp(columnName, x);
        recordbuffer_setfieldvalue(columnName, new java.sql.Timestamp(x.getTime()));
    }


    public boolean wasNull() throws SQLException
    {
        return super_rs.wasNull();
    }


    // sucht feld in der Liste, und erzeugt es ggf neu
    // Sortiert ggf!
    private FieldValue recordbuffer_assertfield(String p_fieldname, boolean p_create)
    {
        FieldValue result = null;
        recordbuffer_sortbyname();
        FieldValue fv = new FieldValue(p_fieldname); // dient nur zum Suchen
        int        i = Collections.binarySearch(recordbuffer, fv);
        result = (i >= 0) ? (FieldValue) recordbuffer.get(i) : null;
        if ((result == null) && p_create) {
            // field noch nicht in der Liste, lege es an.
            recordbuffer.add(fv);
            recordbuffer_sortedbyname     = false; // ist jetzt in Unordnung
            result                        = fv;
        }
        return result;
    }


    private void recordbuffer_assertvtfield(int p_paramnr, int p_sqlType, String p_fieldname)
    {
        FieldValue fv = recordbuffer_assertfield(p_fieldname, false);
        if (fv == null) { // neu in recordbuffer_tmp anlegen.
            fv = new FieldValue(p_fieldname);
            recordbuffer_tmp.add(fv);
        }

        fv.paramnr     = p_paramnr;
        fv.sqltype     = p_sqlType;
        // der Typ ist erstmal egal:
        // der Transfer zwischen recordbuffer und stored proc geht per getObject()/setObject()
    }


    private void recordbuffer_assertvtfield_fixup(boolean p_copy_record_values)
        throws SQLException
    {
        if (p_copy_record_values)
            // für eben neu angelegte Felder die Werte aus super_rs übernehmen.
            for (int i = 0; i < recordbuffer_tmp.size(); i++) {
                FieldValue fv = (FieldValue) recordbuffer_tmp.get(i);
                fv.value = super_rs.getObject(fv.paramnr);
            }

        // Existieren Parameter im recordbuffer, die in der virtab nicht vorkommen .... Fehler!
        for (int i = 0; i < recordbuffer.size(); i++) {
            FieldValue fv = (FieldValue) recordbuffer.get(i);
            if (fv.paramnr == -1)
                throw new SQLException("Ungueltiges Feld '" + fv.name + "' im recordpuffer!");
        }

        // Listen mergen
        for (int i = 0; i < recordbuffer_tmp.size(); i++) {
            recordbuffer.add(recordbuffer_tmp.get(i));
            recordbuffer_sortedbyname = false; // ist jetzt in Unordnung
        }

        recordbuffer_tmp.clear();
    }


    // sicherstellen, dass ein Parameter die für die stored procs geforderten
    // eigenschaften hat. Wenn er noch nicht im Recordpuffer war,
    // wird er neu erzeugt.
    // Optimierung zur Verhinderung ständigen Sortierens von "record_buffer"
    // neue Felder werden zunächst in "recordbuffer_tmp" gespeichert, dadurch
    // bleibt "recordbuffer" sortiert.
    // In "recordbuffer_tmp" wird nie gesucht, diese Liste wird nie sortiert.
    // in recordbuffer_assertvtfield_fixpup() werden dann beide Lsiten gemergt,
    // und "recordbuffer" muss danach einmalig neu sortiert werden.
    private void recordbuffer_assertvtfield_init()
    {
        recordbuffer_tmp.clear();
        // parameternummern als ungueltig markieren
        for (int i = 0; i < recordbuffer.size(); i++) {
            FieldValue fv = (FieldValue) (recordbuffer.get(i));
            fv.paramnr = -1;
        }
    }


    // sucht feld in der Liste. null, wenn nicht da
    private FieldValue recordbuffer_findfield(String p_fieldname)
    {
        FieldValue result = null;
        recordbuffer_sortbyname();
        FieldValue fv = new FieldValue(p_fieldname); // dient nur zum Suchen
        int        i = Collections.binarySearch(recordbuffer, fv);
        return (i >= 0) ? ((FieldValue) (recordbuffer.get(i))) : null;
    }


    // sicherstellen, dass alle Parmeter der stored procs als felder
    // im recordpufer sind. Und für jeden fieldvalue
    // die Parmeternr "paramnr" setzen.
    // Ist "p_copy_record_values" true, werden für neu eingefügte Felder Werte aus
    // dem originalen ResultSet-Record übernommen, sonst geNULLt
    //


    private void recordbuffer_fit_to_virtab_SALES(boolean p_copy_record_values) throws SQLException {
        recordbuffer_assertvtfield_init();
        recordbuffer_assertvtfield(1, java.sql.Types.INTEGER, "SALESPERSON_ID");
        recordbuffer_assertvtfield(2, java.sql.Types.INTEGER, "CUSTOMER_ID");
        recordbuffer_assertvtfield(3, java.sql.Types.VARCHAR, "CUSTOMER");
        recordbuffer_assertvtfield(4, java.sql.Types.INTEGER, "PRODUCT_ID");
        recordbuffer_assertvtfield(5, java.sql.Types.VARCHAR, "PRODUCT");
        recordbuffer_assertvtfield_fixup(p_copy_record_values);
    } // recordbuffer_fit_to_virtab_SALES() 


    private void recordbuffer_fit_to_virtab_DEPTS(boolean p_copy_record_values) throws SQLException {
        recordbuffer_assertvtfield_init();
        recordbuffer_assertvtfield(1, java.sql.Types.VARCHAR, "REGIONAL_GROUP");
        recordbuffer_assertvtfield(2, java.sql.Types.VARCHAR, "DEPARTMENT_NAME");
        recordbuffer_assertvtfield(3, java.sql.Types.VARCHAR, "STREET");
        recordbuffer_assertvtfield(4, java.sql.Types.VARCHAR, "CITY");
        recordbuffer_assertvtfield(5, java.sql.Types.VARCHAR, "STATE");
        recordbuffer_assertvtfield(6, java.sql.Types.VARCHAR, "ZIP_CODE");
        recordbuffer_assertvtfield_fixup(p_copy_record_values);
    } // recordbuffer_fit_to_virtab_DEPTS() 


    private void recordbuffer_fit_to_virtab_DEPTS_2(boolean p_copy_record_values) throws SQLException {
        recordbuffer_assertvtfield_init();
        recordbuffer_assertvtfield(1, java.sql.Types.VARCHAR, "REGIONAL_GROUP");
        recordbuffer_assertvtfield(2, java.sql.Types.VARCHAR, "DEPARTMENT");
        recordbuffer_assertvtfield(3, java.sql.Types.VARCHAR, "STREET");
        recordbuffer_assertvtfield(4, java.sql.Types.VARCHAR, "CITY");
        recordbuffer_assertvtfield(5, java.sql.Types.VARCHAR, "STATE");
        recordbuffer_assertvtfield(6, java.sql.Types.VARCHAR, "ZIP_CODE");
        recordbuffer_assertvtfield_fixup(p_copy_record_values);
    } // recordbuffer_fit_to_virtab_DEPTS_2() 


    private void recordbuffer_fit_to_virtab_DEPTS_3(boolean p_copy_record_values) throws SQLException {
        recordbuffer_assertvtfield_init();
        recordbuffer_assertvtfield(1, java.sql.Types.VARCHAR, "REGIONAL_GROUP");
        recordbuffer_assertvtfield(2, java.sql.Types.VARCHAR, "DEPARTMENT");
        recordbuffer_assertvtfield(3, java.sql.Types.VARCHAR, "STREET");
        recordbuffer_assertvtfield(4, java.sql.Types.VARCHAR, "CITY");
        recordbuffer_assertvtfield(5, java.sql.Types.VARCHAR, "STATE");
        recordbuffer_assertvtfield(6, java.sql.Types.VARCHAR, "ZIP_CODE");
        recordbuffer_assertvtfield_fixup(p_copy_record_values);
    } // recordbuffer_fit_to_virtab_DEPTS_3() 


    private void recordbuffer_fit_to_virtab_DEPTS_4(boolean p_copy_record_values) throws SQLException {
        recordbuffer_assertvtfield_init();
        recordbuffer_assertvtfield(1, java.sql.Types.VARCHAR, "REGIONAL_GROUP");
        recordbuffer_assertvtfield(2, java.sql.Types.VARCHAR, "DEPARTMENT");
        recordbuffer_assertvtfield_fixup(p_copy_record_values);
    } // recordbuffer_fit_to_virtab_DEPTS_4() 


    private void recordbuffer_fit_to_virtab_DEPTS_5(boolean p_copy_record_values) throws SQLException {
        recordbuffer_assertvtfield_init();
        recordbuffer_assertvtfield(1, java.sql.Types.VARCHAR, "REGIONAL_GROUP");
        recordbuffer_assertvtfield(2, java.sql.Types.VARCHAR, "DEPARTMENT");
        recordbuffer_assertvtfield(3, java.sql.Types.VARCHAR, "STREET");
        recordbuffer_assertvtfield(4, java.sql.Types.VARCHAR, "CITY");
        recordbuffer_assertvtfield(5, java.sql.Types.VARCHAR, "STATE");
        recordbuffer_assertvtfield(6, java.sql.Types.VARCHAR, "ZIP_CODE");
        recordbuffer_assertvtfield_fixup(p_copy_record_values);
    } // recordbuffer_fit_to_virtab_DEPTS_5() 


    private void recordbuffer_fit_to_virtab_DEPTS_6(boolean p_copy_record_values) throws SQLException {
        recordbuffer_assertvtfield_init();
        recordbuffer_assertvtfield(1, java.sql.Types.VARCHAR, "DEPARTMENT");
        recordbuffer_assertvtfield(2, java.sql.Types.VARCHAR, "STREET");
        recordbuffer_assertvtfield(3, java.sql.Types.VARCHAR, "CITY");
        recordbuffer_assertvtfield(4, java.sql.Types.VARCHAR, "STATE");
        recordbuffer_assertvtfield(5, java.sql.Types.VARCHAR, "ZIP_CODE");
        recordbuffer_assertvtfield_fixup(p_copy_record_values);
    } // recordbuffer_fit_to_virtab_DEPTS_6() 


    private void recordbuffer_fit_to_virtab_letter_data(boolean p_copy_record_values) throws SQLException {
        recordbuffer_assertvtfield_init();
        recordbuffer_assertvtfield(1, java.sql.Types.VARCHAR, "EMP_FIRST_NAME");
        recordbuffer_assertvtfield(2, java.sql.Types.VARCHAR, "EMP_LAST_NAME");
        recordbuffer_assertvtfield(3, java.sql.Types.VARCHAR, "EMP_STREET");
        recordbuffer_assertvtfield(4, java.sql.Types.VARCHAR, "EMP_CITY");
        recordbuffer_assertvtfield(5, java.sql.Types.VARCHAR, "EMP_STATE");
        recordbuffer_assertvtfield(6, java.sql.Types.VARCHAR, "EMP_ZIP_CODE");
        recordbuffer_assertvtfield(7, java.sql.Types.VARCHAR, "EMP_DEPARTMENT");
        recordbuffer_assertvtfield(8, java.sql.Types.VARCHAR, "EMP_LOC");
        recordbuffer_assertvtfield(9, java.sql.Types.VARCHAR, "CUST_NAME");
        recordbuffer_assertvtfield(10, java.sql.Types.VARCHAR, "CUST_STREET");
        recordbuffer_assertvtfield(11, java.sql.Types.VARCHAR, "CUST_CITY");
        recordbuffer_assertvtfield(12, java.sql.Types.VARCHAR, "CUST_STATE");
        recordbuffer_assertvtfield(13, java.sql.Types.VARCHAR, "CUST_ZIP_CODE");
        recordbuffer_assertvtfield_fixup(p_copy_record_values);
    } // recordbuffer_fit_to_virtab_letter_data() 


    private void recordbuffer_fit_to_virtab_HIERARCHY(boolean p_copy_record_values) throws SQLException {
        recordbuffer_assertvtfield_init();
        recordbuffer_assertvtfield(1, java.sql.Types.VARCHAR, "BOSS");
        recordbuffer_assertvtfield(2, java.sql.Types.VARCHAR, "BOSS_JOB");
        recordbuffer_assertvtfield(3, java.sql.Types.VARCHAR, "SLAVE");
        recordbuffer_assertvtfield(4, java.sql.Types.VARCHAR, "SLAVE_JOB");
        recordbuffer_assertvtfield(5, java.sql.Types.VARCHAR, "SLAVE_LOC");
        recordbuffer_assertvtfield(6, java.sql.Types.VARCHAR, "SLAVE_DEPT");
        recordbuffer_assertvtfield_fixup(p_copy_record_values);
    } // recordbuffer_fit_to_virtab_HIERARCHY() 


    private void recordbuffer_fit_to_virtab_DEPTSINFO(boolean p_copy_record_values) throws SQLException {
        recordbuffer_assertvtfield_init();
        recordbuffer_assertvtfield(1, java.sql.Types.VARCHAR, "REGIONAL_GROUP");
        recordbuffer_assertvtfield(2, java.sql.Types.VARCHAR, "DEPARTMENT_NAME");
        recordbuffer_assertvtfield(3, java.sql.Types.VARCHAR, "STREET");
        recordbuffer_assertvtfield(4, java.sql.Types.VARCHAR, "CITY");
        recordbuffer_assertvtfield(5, java.sql.Types.VARCHAR, "STATE");
        recordbuffer_assertvtfield(6, java.sql.Types.VARCHAR, "ZIP_CODE");
        recordbuffer_assertvtfield(7, java.sql.Types.VARCHAR, "DEPT_PER_LOC");
        recordbuffer_assertvtfield_fixup(p_copy_record_values);
    } // recordbuffer_fit_to_virtab_DEPTSINFO() 


    private void recordbuffer_fit_to_virtab_DEPTSINFO1(boolean p_copy_record_values) throws SQLException {
        recordbuffer_assertvtfield_init();
        recordbuffer_assertvtfield(1, java.sql.Types.VARCHAR, "REGIONAL_GROUP");
        recordbuffer_assertvtfield(2, java.sql.Types.VARCHAR, "DEPARTMENT_NAME");
        recordbuffer_assertvtfield(3, java.sql.Types.VARCHAR, "STREET");
        recordbuffer_assertvtfield(4, java.sql.Types.VARCHAR, "CITY");
        recordbuffer_assertvtfield(5, java.sql.Types.VARCHAR, "STATE");
        recordbuffer_assertvtfield(6, java.sql.Types.VARCHAR, "ZIP_CODE");
        recordbuffer_assertvtfield(7, java.sql.Types.VARCHAR, "LOC_PER_DEPT");
        recordbuffer_assertvtfield_fixup(p_copy_record_values);
    } // recordbuffer_fit_to_virtab_DEPTSINFO1() 


    private void recordbuffer_fit_to_virtab(int p_virtabkind, boolean p_copy_record_values)
        throws SQLException
    {
        switch (p_virtabkind) {
        case vtkSALES:
            recordbuffer_fit_to_virtab_SALES(p_copy_record_values);
            break; // case vtkSALES
        case vtkDEPTS:
            recordbuffer_fit_to_virtab_DEPTS(p_copy_record_values);
            break; // case vtkDEPTS
        case vtkDEPTS_2:
            recordbuffer_fit_to_virtab_DEPTS_2(p_copy_record_values);
            break; // case vtkDEPTS_2
        case vtkDEPTS_3:
            recordbuffer_fit_to_virtab_DEPTS_3(p_copy_record_values);
            break; // case vtkDEPTS_3
        case vtkDEPTS_4:
            recordbuffer_fit_to_virtab_DEPTS_4(p_copy_record_values);
            break; // case vtkDEPTS_4
        case vtkDEPTS_5:
            recordbuffer_fit_to_virtab_DEPTS_5(p_copy_record_values);
            break; // case vtkDEPTS_5
        case vtkDEPTS_6:
            recordbuffer_fit_to_virtab_DEPTS_6(p_copy_record_values);
            break; // case vtkDEPTS_6
        case vtkletter_data:
            recordbuffer_fit_to_virtab_letter_data(p_copy_record_values);
            break; // case vtkletter_data
        case vtkletter_data_emp:
            throw new SQLException("Virtab letter_data_emp ist NOCHANGE, die procedures duerfen nicht aufgerufen werden!");
        case vtkletter_data_cust:
            throw new SQLException("Virtab letter_data_cust ist NOCHANGE, die procedures duerfen nicht aufgerufen werden!");
        case vtkletter_data_main:
            throw new SQLException("Virtab letter_data_main ist NOCHANGE, die procedures duerfen nicht aufgerufen werden!");
        case vtkHIERARCHY:
            recordbuffer_fit_to_virtab_HIERARCHY(p_copy_record_values);
            break; // case vtkHIERARCHY
        case vtkDEPTSINFO:
            recordbuffer_fit_to_virtab_DEPTSINFO(p_copy_record_values);
            break; // case vtkDEPTSINFO
        case vtkDEPTSINFO1:
            recordbuffer_fit_to_virtab_DEPTSINFO1(p_copy_record_values);
            break; // case vtkDEPTSINFO1
        } // switch (p_virtabkind)
    } // recordbuffer_fit_to_virtab()


    // Feldwert abfragen. Wenn nicht in der Liste, dann aus dem Record selbst holen
    private Object recordbuffer_getfieldvalue(String p_fieldname)
        throws SQLException
    {
        // Check: Eintrag fuer "fieldname" schon in der Liste
        FieldValue fv = recordbuffer_findfield(p_fieldname);
        if (fv != null)
            return fv.value;
        else if (in_insert)
            // insert => keine Defaultdaten da: gib NULL zurück.
            return null;
        else
            // update: gibt Felder aus dem aktuellen Record zurück
            return super_rs.getObject(p_fieldname);
    }


    // Feld auf einen Wert setzen
    private void recordbuffer_setfieldvalue(String p_fieldname, Object p_o)
    {
        // Check: Eintrag fuer "fieldname" schon in der Liste
        FieldValue fv = recordbuffer_assertfield(p_fieldname, true);
        fv.value = p_o;
    }


    // Feldliste sortieren, wenn sie es nicht ist.
    private void recordbuffer_sortbyname()
    {
        if (! recordbuffer_sortedbyname)
            Collections.sort(recordbuffer);
        recordbuffer_sortedbyname = true;
    }


    /* Aufruf einer Virtab-stored proc
     * sel_insupddel: 1 = insert, 2 = update, 3 = delete
     * Procedure abhängig vom Virtabkind
     * Nimmt die gesetzten Werte aus dem recordbuffer
     */


    private CallableStatement vt_setupProc_SALES(int p_vtproctype) throws SQLException { 
        CallableStatement cs = null;
        switch (p_vtproctype) {
        case vtproctypeInsert:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pi_SALES(?,?,?,?,?)}");
            break;
        case vtproctypeUpdate:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pu_SALES(?,?,?,?,?)}");
            break;
        case vtproctypeDelete:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pd_SALES(?,?,?,?,?)}");
            break;
        }
        cs.registerOutParameter(1, java.sql.Types.INTEGER); // SALESPERSON_ID
        cs.registerOutParameter(2, java.sql.Types.INTEGER); // CUSTOMER_ID
        cs.registerOutParameter(3, java.sql.Types.VARCHAR); // CUSTOMER
        cs.registerOutParameter(4, java.sql.Types.INTEGER); // PRODUCT_ID
        cs.registerOutParameter(5, java.sql.Types.VARCHAR); // PRODUCT
        return cs;
    } // vt_setupProc_SALES()


    private CallableStatement vt_setupProc_DEPTS(int p_vtproctype) throws SQLException { 
        CallableStatement cs = null;
        switch (p_vtproctype) {
        case vtproctypeInsert:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pi_DEPTS(?,?,?,?,?,?)}");
            break;
        case vtproctypeUpdate:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pu_DEPTS(?,?,?,?,?,?)}");
            break;
        case vtproctypeDelete:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pd_DEPTS(?,?,?,?,?,?)}");
            break;
        }
        cs.registerOutParameter(1, java.sql.Types.VARCHAR); // REGIONAL_GROUP
        cs.registerOutParameter(2, java.sql.Types.VARCHAR); // DEPARTMENT_NAME
        cs.registerOutParameter(3, java.sql.Types.VARCHAR); // STREET
        cs.registerOutParameter(4, java.sql.Types.VARCHAR); // CITY
        cs.registerOutParameter(5, java.sql.Types.VARCHAR); // STATE
        cs.registerOutParameter(6, java.sql.Types.VARCHAR); // ZIP_CODE
        return cs;
    } // vt_setupProc_DEPTS()


    private CallableStatement vt_setupProc_DEPTS_2(int p_vtproctype) throws SQLException { 
        CallableStatement cs = null;
        switch (p_vtproctype) {
        case vtproctypeInsert:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pi_DEPTS_2(?,?,?,?,?,?)}");
            break;
        case vtproctypeUpdate:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pu_DEPTS_2(?,?,?,?,?,?)}");
            break;
        case vtproctypeDelete:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pd_DEPTS_2(?,?,?,?,?,?)}");
            break;
        }
        cs.registerOutParameter(1, java.sql.Types.VARCHAR); // REGIONAL_GROUP
        cs.registerOutParameter(2, java.sql.Types.VARCHAR); // DEPARTMENT
        cs.registerOutParameter(3, java.sql.Types.VARCHAR); // STREET
        cs.registerOutParameter(4, java.sql.Types.VARCHAR); // CITY
        cs.registerOutParameter(5, java.sql.Types.VARCHAR); // STATE
        cs.registerOutParameter(6, java.sql.Types.VARCHAR); // ZIP_CODE
        return cs;
    } // vt_setupProc_DEPTS_2()


    private CallableStatement vt_setupProc_DEPTS_3(int p_vtproctype) throws SQLException { 
        CallableStatement cs = null;
        switch (p_vtproctype) {
        case vtproctypeInsert:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pi_DEPTS_3(?,?,?,?,?,?)}");
            break;
        case vtproctypeUpdate:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pu_DEPTS_3(?,?,?,?,?,?)}");
            break;
        case vtproctypeDelete:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pd_DEPTS_3(?,?,?,?,?,?)}");
            break;
        }
        cs.registerOutParameter(1, java.sql.Types.VARCHAR); // REGIONAL_GROUP
        cs.registerOutParameter(2, java.sql.Types.VARCHAR); // DEPARTMENT
        cs.registerOutParameter(3, java.sql.Types.VARCHAR); // STREET
        cs.registerOutParameter(4, java.sql.Types.VARCHAR); // CITY
        cs.registerOutParameter(5, java.sql.Types.VARCHAR); // STATE
        cs.registerOutParameter(6, java.sql.Types.VARCHAR); // ZIP_CODE
        return cs;
    } // vt_setupProc_DEPTS_3()


    private CallableStatement vt_setupProc_DEPTS_4(int p_vtproctype) throws SQLException { 
        CallableStatement cs = null;
        switch (p_vtproctype) {
        case vtproctypeInsert:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pi_DEPTS_4(?,?)}");
            break;
        case vtproctypeUpdate:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pu_DEPTS_4(?,?)}");
            break;
        case vtproctypeDelete:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pd_DEPTS_4(?,?)}");
            break;
        }
        cs.registerOutParameter(1, java.sql.Types.VARCHAR); // REGIONAL_GROUP
        cs.registerOutParameter(2, java.sql.Types.VARCHAR); // DEPARTMENT
        return cs;
    } // vt_setupProc_DEPTS_4()


    private CallableStatement vt_setupProc_DEPTS_5(int p_vtproctype) throws SQLException { 
        CallableStatement cs = null;
        switch (p_vtproctype) {
        case vtproctypeInsert:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pi_DEPTS_5(?,?,?,?,?,?)}");
            break;
        case vtproctypeUpdate:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pu_DEPTS_5(?,?,?,?,?,?)}");
            break;
        case vtproctypeDelete:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pd_DEPTS_5(?,?,?,?,?,?)}");
            break;
        }
        cs.registerOutParameter(1, java.sql.Types.VARCHAR); // REGIONAL_GROUP
        cs.registerOutParameter(2, java.sql.Types.VARCHAR); // DEPARTMENT
        cs.registerOutParameter(3, java.sql.Types.VARCHAR); // STREET
        cs.registerOutParameter(4, java.sql.Types.VARCHAR); // CITY
        cs.registerOutParameter(5, java.sql.Types.VARCHAR); // STATE
        cs.registerOutParameter(6, java.sql.Types.VARCHAR); // ZIP_CODE
        return cs;
    } // vt_setupProc_DEPTS_5()


    private CallableStatement vt_setupProc_DEPTS_6(int p_vtproctype) throws SQLException { 
        CallableStatement cs = null;
        switch (p_vtproctype) {
        case vtproctypeInsert:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pi_DEPTS_6(?,?,?,?,?)}");
            break;
        case vtproctypeUpdate:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pu_DEPTS_6(?,?,?,?,?)}");
            break;
        case vtproctypeDelete:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pd_DEPTS_6(?,?,?,?,?)}");
            break;
        }
        cs.registerOutParameter(1, java.sql.Types.VARCHAR); // DEPARTMENT
        cs.registerOutParameter(2, java.sql.Types.VARCHAR); // STREET
        cs.registerOutParameter(3, java.sql.Types.VARCHAR); // CITY
        cs.registerOutParameter(4, java.sql.Types.VARCHAR); // STATE
        cs.registerOutParameter(5, java.sql.Types.VARCHAR); // ZIP_CODE
        return cs;
    } // vt_setupProc_DEPTS_6()


    private CallableStatement vt_setupProc_letter_data(int p_vtproctype) throws SQLException { 
        CallableStatement cs = null;
        switch (p_vtproctype) {
        case vtproctypeInsert:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pi_letter_data(?,?,?,?,?,?,?,?,?,?,?,?,?)}");
            break;
        case vtproctypeUpdate:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pu_letter_data(?,?,?,?,?,?,?,?,?,?,?,?,?)}");
            break;
        case vtproctypeDelete:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pd_letter_data(?,?,?,?,?,?,?,?,?,?,?,?,?)}");
            break;
        }
        cs.registerOutParameter(1, java.sql.Types.VARCHAR); // EMP_FIRST_NAME
        cs.registerOutParameter(2, java.sql.Types.VARCHAR); // EMP_LAST_NAME
        cs.registerOutParameter(3, java.sql.Types.VARCHAR); // EMP_STREET
        cs.registerOutParameter(4, java.sql.Types.VARCHAR); // EMP_CITY
        cs.registerOutParameter(5, java.sql.Types.VARCHAR); // EMP_STATE
        cs.registerOutParameter(6, java.sql.Types.VARCHAR); // EMP_ZIP_CODE
        cs.registerOutParameter(7, java.sql.Types.VARCHAR); // EMP_DEPARTMENT
        cs.registerOutParameter(8, java.sql.Types.VARCHAR); // EMP_LOC
        cs.registerOutParameter(9, java.sql.Types.VARCHAR); // CUST_NAME
        cs.registerOutParameter(10, java.sql.Types.VARCHAR); // CUST_STREET
        cs.registerOutParameter(11, java.sql.Types.VARCHAR); // CUST_CITY
        cs.registerOutParameter(12, java.sql.Types.VARCHAR); // CUST_STATE
        cs.registerOutParameter(13, java.sql.Types.VARCHAR); // CUST_ZIP_CODE
        return cs;
    } // vt_setupProc_letter_data()


    private CallableStatement vt_setupProc_HIERARCHY(int p_vtproctype) throws SQLException { 
        CallableStatement cs = null;
        switch (p_vtproctype) {
        case vtproctypeInsert:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pi_HIERARCHY(?,?,?,?,?,?)}");
            break;
        case vtproctypeUpdate:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pu_HIERARCHY(?,?,?,?,?,?)}");
            break;
        case vtproctypeDelete:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pd_HIERARCHY(?,?,?,?,?,?)}");
            break;
        }
        cs.registerOutParameter(1, java.sql.Types.VARCHAR); // BOSS
        cs.registerOutParameter(2, java.sql.Types.VARCHAR); // BOSS_JOB
        cs.registerOutParameter(3, java.sql.Types.VARCHAR); // SLAVE
        cs.registerOutParameter(4, java.sql.Types.VARCHAR); // SLAVE_JOB
        cs.registerOutParameter(5, java.sql.Types.VARCHAR); // SLAVE_LOC
        cs.registerOutParameter(6, java.sql.Types.VARCHAR); // SLAVE_DEPT
        return cs;
    } // vt_setupProc_HIERARCHY()


    private CallableStatement vt_setupProc_DEPTSINFO(int p_vtproctype) throws SQLException { 
        CallableStatement cs = null;
        switch (p_vtproctype) {
        case vtproctypeInsert:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pi_DEPTSINFO(?,?,?,?,?,?,?)}");
            break;
        case vtproctypeUpdate:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pu_DEPTSINFO(?,?,?,?,?,?,?)}");
            break;
        case vtproctypeDelete:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pd_DEPTSINFO(?,?,?,?,?,?,?)}");
            break;
        }
        cs.registerOutParameter(1, java.sql.Types.VARCHAR); // REGIONAL_GROUP
        cs.registerOutParameter(2, java.sql.Types.VARCHAR); // DEPARTMENT_NAME
        cs.registerOutParameter(3, java.sql.Types.VARCHAR); // STREET
        cs.registerOutParameter(4, java.sql.Types.VARCHAR); // CITY
        cs.registerOutParameter(5, java.sql.Types.VARCHAR); // STATE
        cs.registerOutParameter(6, java.sql.Types.VARCHAR); // ZIP_CODE
        cs.registerOutParameter(7, java.sql.Types.VARCHAR); // DEPT_PER_LOC
        return cs;
    } // vt_setupProc_DEPTSINFO()


    private CallableStatement vt_setupProc_DEPTSINFO1(int p_vtproctype) throws SQLException { 
        CallableStatement cs = null;
        switch (p_vtproctype) {
        case vtproctypeInsert:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pi_DEPTSINFO1(?,?,?,?,?,?,?)}");
            break;
        case vtproctypeUpdate:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pu_DEPTSINFO1(?,?,?,?,?,?,?)}");
            break;
        case vtproctypeDelete:
            cs = super_rs.getStatement().getConnection().prepareCall(
                "{call pd_DEPTSINFO1(?,?,?,?,?,?,?)}");
            break;
        }
        cs.registerOutParameter(1, java.sql.Types.VARCHAR); // REGIONAL_GROUP
        cs.registerOutParameter(2, java.sql.Types.VARCHAR); // DEPARTMENT_NAME
        cs.registerOutParameter(3, java.sql.Types.VARCHAR); // STREET
        cs.registerOutParameter(4, java.sql.Types.VARCHAR); // CITY
        cs.registerOutParameter(5, java.sql.Types.VARCHAR); // STATE
        cs.registerOutParameter(6, java.sql.Types.VARCHAR); // ZIP_CODE
        cs.registerOutParameter(7, java.sql.Types.VARCHAR); // LOC_PER_DEPT
        return cs;
    } // vt_setupProc_DEPTSINFO1()


    private void vt_callProc(int p_vtproctype, int p_virtabkind)
        throws SQLException
    {
        // CallableStatements: jede einmal geöffnete Procedure wird in
        // this.vt_proc[insupddel] gehalten
        CallableStatement cs = null;
        if (vt_proc[p_vtproctype] != null) // diese Storedproc wurde schon mal benutzt: reuse

            cs = vt_proc[p_vtproctype];
        else {
            // Procedure erzeugen, und Parmeter registrieren.
            switch (p_virtabkind) {
            case vtkSALES:
                cs = vt_setupProc_SALES(p_vtproctype) ;
                break;
            case vtkDEPTS:
                cs = vt_setupProc_DEPTS(p_vtproctype) ;
                break;
            case vtkDEPTS_2:
                cs = vt_setupProc_DEPTS_2(p_vtproctype) ;
                break;
            case vtkDEPTS_3:
                cs = vt_setupProc_DEPTS_3(p_vtproctype) ;
                break;
            case vtkDEPTS_4:
                cs = vt_setupProc_DEPTS_4(p_vtproctype) ;
                break;
            case vtkDEPTS_5:
                cs = vt_setupProc_DEPTS_5(p_vtproctype) ;
                break;
            case vtkDEPTS_6:
                cs = vt_setupProc_DEPTS_6(p_vtproctype) ;
                break;
            case vtkletter_data:
                cs = vt_setupProc_letter_data(p_vtproctype) ;
                break;
            case vtkletter_data_emp:
                throw new SQLException("Virtab letter_data_emp ist NOCHANGE, die procedures duerfen nicht aufgerufen werden!");
            case vtkletter_data_cust:
                throw new SQLException("Virtab letter_data_cust ist NOCHANGE, die procedures duerfen nicht aufgerufen werden!");
            case vtkletter_data_main:
                throw new SQLException("Virtab letter_data_main ist NOCHANGE, die procedures duerfen nicht aufgerufen werden!");
            case vtkHIERARCHY:
                cs = vt_setupProc_HIERARCHY(p_vtproctype) ;
                break;
            case vtkDEPTSINFO:
                cs = vt_setupProc_DEPTSINFO(p_vtproctype) ;
                break;
            case vtkDEPTSINFO1:
                cs = vt_setupProc_DEPTSINFO1(p_vtproctype) ;
                break;
            }
            vt_proc[p_vtproctype] = cs;
        }

        // Felder im Recordpuffer mit Virtabprozedur abgleichen
        // bei Insert: nicht gesetzte Felder NULLen, für udpate/delte Werte aus
        // aktuellem super_rs.record übernehmen
        recordbuffer_fit_to_virtab(p_virtabkind, p_vtproctype != vtproctypeInsert);

        // Parameter aus recordbuffer in die Procedur kopieren
        for (int i = 0; i < recordbuffer.size(); i++) {
            FieldValue fv = (FieldValue) (recordbuffer.get(i));
            if (fv.value == null)
                cs.setNull(fv.paramnr, fv.sqltype);
            else
                cs.setObject(fv.paramnr, fv.value);
        }

        // Procedur ausführen
        cs.execute();

        // alle Parameter sind out: kopieren ihre Werte zurück in den recordbuffer.
        // numerische Werte als BigDecimal im RecordBuffer speichern
        for (int i = 0; i < recordbuffer.size(); i++) {
            FieldValue fv = (FieldValue) (recordbuffer.get(i));
            switch(fv.sqltype) {
            // Die Virtabs kennen nur int und double
            case java.sql.Types.INTEGER:
                fv.value = new BigDecimal(cs.getInt(fv.paramnr)) ;
                break ;
            case java.sql.Types.DOUBLE:
                fv.value = new BigDecimal(cs.getDouble(fv.paramnr)) ;
                break ;
            default:
                fv.value = cs.getObject(fv.paramnr);
            }
        }
        cs.close(); // unbedingt, sonst memory-Frass!

        // Die ueberschriebenen 'getXxxx(fieldname)' liefern jetzt Werte aus dem recordbuffer.
        // Navigationsaufrufe (last(), first(), next(), previous(), first(), moveToCurrentRow()
        // löschen aber den recordbuffer, so dass wieder Zugriff
        //
    } // vt_callProc()


    // Gibt zu einer VirtabKind den Virtabnamen zurueck.
    // Bei Fehler gibts ''
    // Wenn 'p_viewname'=true: Ergebnis mit Prefix 'VT_', sonst nur der Virtabname
    public static String VTKind2Name(int p_vtkind, boolean p_viewname) {
        String vtname = null;
        switch(p_vtkind) {
        case vtkSALES: vtname = "SALES" ; break ;
        case vtkDEPTS: vtname = "DEPTS" ; break ;
        case vtkDEPTS_2: vtname = "DEPTS_2" ; break ;
        case vtkDEPTS_3: vtname = "DEPTS_3" ; break ;
        case vtkDEPTS_4: vtname = "DEPTS_4" ; break ;
        case vtkDEPTS_5: vtname = "DEPTS_5" ; break ;
        case vtkDEPTS_6: vtname = "DEPTS_6" ; break ;
        case vtkletter_data: vtname = "letter_data" ; break ;
        case vtkletter_data_emp: vtname = "letter_data_emp" ; break ;
        case vtkletter_data_cust: vtname = "letter_data_cust" ; break ;
        case vtkletter_data_main: vtname = "letter_data_main" ; break ;
        case vtkHIERARCHY: vtname = "HIERARCHY" ; break ;
        case vtkDEPTSINFO: vtname = "DEPTSINFO" ; break ;
        case vtkDEPTSINFO1: vtname = "DEPTSINFO1" ; break ;
        }
        if (vtname != null && p_viewname) return "VT_" + vtname ;
        else return vtname ;
    } // VTKind2Name()


    // Gibt zu einem Virtabnamen den VirtabKind.
    // Bei Fehler gibts 'vtkNone'
    // Wenn 'p_viewname'=true: Ergebnis mit Prefix 'VT_', sonst nur der Virtabname
    // Sehr schlechte Implementierung! Besser waere binary search in sorted ArrayList
    public static int VTName2Kind(String p_vtname, boolean p_viewname) {
        if (p_vtname != null && p_viewname) p_vtname = "VT_" + p_vtname ;
        if (p_vtname.equalsIgnoreCase("VT_SALES")) return vtkSALES;
        if (p_vtname.equalsIgnoreCase("VT_DEPTS")) return vtkDEPTS;
        if (p_vtname.equalsIgnoreCase("VT_DEPTS_2")) return vtkDEPTS_2;
        if (p_vtname.equalsIgnoreCase("VT_DEPTS_3")) return vtkDEPTS_3;
        if (p_vtname.equalsIgnoreCase("VT_DEPTS_4")) return vtkDEPTS_4;
        if (p_vtname.equalsIgnoreCase("VT_DEPTS_5")) return vtkDEPTS_5;
        if (p_vtname.equalsIgnoreCase("VT_DEPTS_6")) return vtkDEPTS_6;
        if (p_vtname.equalsIgnoreCase("VT_letter_data")) return vtkletter_data;
        if (p_vtname.equalsIgnoreCase("VT_letter_data_emp")) return vtkletter_data_emp;
        if (p_vtname.equalsIgnoreCase("VT_letter_data_cust")) return vtkletter_data_cust;
        if (p_vtname.equalsIgnoreCase("VT_letter_data_main")) return vtkletter_data_main;
        if (p_vtname.equalsIgnoreCase("VT_HIERARCHY")) return vtkHIERARCHY;
        if (p_vtname.equalsIgnoreCase("VT_DEPTSINFO")) return vtkDEPTSINFO;
        if (p_vtname.equalsIgnoreCase("VT_DEPTSINFO1")) return vtkDEPTSINFO1;
        return vtkNone ;
    } // VTName2Kind()


    //~ Inner Classes --------------------------------------------------------------------------------------------------------------

    // Speichert einen Feldwert, als element eines Hashsets.
    private class FieldValue extends Object implements Comparable
    {
        //~ Instance fields --------------------------------------------------------------------------------------------------------

        Object value; // der Wert des Feldes
        String name; // der Feldname
        int    paramnr; // Index in der storedprocedure der zueghörigen Virtab
        int    sqltype; // Type des stored proc Parmaeters (aus java.sql.types.)

        //~ Constructors -----------------------------------------------------------------------------------------------------------

        FieldValue(String p_fieldname)
        {
            name        = p_fieldname;
            value       = null;
            paramnr     = -1;
        }

        //~ Methods ----------------------------------------------------------------------------------------------------------------

        // Mit anderem fieldvalue vergleichen, auf Basis des fieldname
        public int compareTo(Object o)
        {
            return name.compareToIgnoreCase(((FieldValue) o).name);
        }
    }

}