package com.sap.dbtech.jdbc.trace;


import com.sap.dbtech.util.Tracer;

public class ResultSet implements java.sql.ResultSet
{
    private java.sql.ResultSet _inner;
    // nothing in genAdditionalInstanceVars
    public java.sql.ResultSet getInner() {
      return (java.sql.ResultSet) this._inner;
    }
    static java.sql.ResultSet getInner (java.sql.ResultSet obj ) {
      if (obj == null || ! (obj instanceof com.sap.dbtech.jdbc.trace.ResultSet))  { 
        return null;  
      }
      ResultSet iobj = (ResultSet)obj;
      return (java.sql.ResultSet)iobj._inner;
    }
    static java.sql.ResultSet createNew (java.sql.ResultSet obj ) {
      ResultSet iobj = new ResultSet (obj);
      return (java.sql.ResultSet)iobj;
    }

    public ResultSet(
        java.sql.ResultSet _innerP)
    {
        this._inner = _innerP;
    }

    public java.lang.Object getObject (
        java.lang.String arg0)
    throws java.sql.SQLException
    {
        java.lang.Object _result;
        Tracer.println (this._inner + ".getObject (" + arg0 + ")");
        try {
            _result = this._inner.getObject (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.lang.Object getObject (
        int arg0)
    throws java.sql.SQLException
    {
        java.lang.Object _result;
        Tracer.println (this._inner + ".getObject (" + arg0 + ")");
        try {
            _result = this._inner.getObject (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.lang.Object getObject (
        java.lang.String arg0,
        java.util.Map arg1)
    throws java.sql.SQLException
    {
        java.lang.Object _result;
        Tracer.println (this._inner + ".getObject (" + arg0 + ", " + arg1 + ")");
        try {
            _result = this._inner.getObject (arg0, arg1);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.lang.Object getObject (
        int arg0,
        java.util.Map arg1)
    throws java.sql.SQLException
    {
        java.lang.Object _result;
        Tracer.println (this._inner + ".getObject (" + arg0 + ", " + arg1 + ")");
        try {
            _result = this._inner.getObject (arg0, arg1);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public boolean getBoolean (
        int arg0)
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".getBoolean (" + arg0 + ")");
        try {
            _result = this._inner.getBoolean (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public boolean getBoolean (
        java.lang.String arg0)
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".getBoolean (" + arg0 + ")");
        try {
            _result = this._inner.getBoolean (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public byte getByte (
        int arg0)
    throws java.sql.SQLException
    {
        byte _result;
        Tracer.println (this._inner + ".getByte (" + arg0 + ")");
        try {
            _result = this._inner.getByte (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public byte getByte (
        java.lang.String arg0)
    throws java.sql.SQLException
    {
        byte _result;
        Tracer.println (this._inner + ".getByte (" + arg0 + ")");
        try {
            _result = this._inner.getByte (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public short getShort (
        int arg0)
    throws java.sql.SQLException
    {
        short _result;
        Tracer.println (this._inner + ".getShort (" + arg0 + ")");
        try {
            _result = this._inner.getShort (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public short getShort (
        java.lang.String arg0)
    throws java.sql.SQLException
    {
        short _result;
        Tracer.println (this._inner + ".getShort (" + arg0 + ")");
        try {
            _result = this._inner.getShort (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public int getInt (
        int arg0)
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getInt (" + arg0 + ")");
        try {
            _result = this._inner.getInt (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public int getInt (
        java.lang.String arg0)
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getInt (" + arg0 + ")");
        try {
            _result = this._inner.getInt (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public long getLong (
        java.lang.String arg0)
    throws java.sql.SQLException
    {
        long _result;
        Tracer.println (this._inner + ".getLong (" + arg0 + ")");
        try {
            _result = this._inner.getLong (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public long getLong (
        int arg0)
    throws java.sql.SQLException
    {
        long _result;
        Tracer.println (this._inner + ".getLong (" + arg0 + ")");
        try {
            _result = this._inner.getLong (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public float getFloat (
        int arg0)
    throws java.sql.SQLException
    {
        float _result;
        Tracer.println (this._inner + ".getFloat (" + arg0 + ")");
        try {
            _result = this._inner.getFloat (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public float getFloat (
        java.lang.String arg0)
    throws java.sql.SQLException
    {
        float _result;
        Tracer.println (this._inner + ".getFloat (" + arg0 + ")");
        try {
            _result = this._inner.getFloat (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public double getDouble (
        int arg0)
    throws java.sql.SQLException
    {
        double _result;
        Tracer.println (this._inner + ".getDouble (" + arg0 + ")");
        try {
            _result = this._inner.getDouble (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public double getDouble (
        java.lang.String arg0)
    throws java.sql.SQLException
    {
        double _result;
        Tracer.println (this._inner + ".getDouble (" + arg0 + ")");
        try {
            _result = this._inner.getDouble (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public byte [] getBytes (
        int arg0)
    throws java.sql.SQLException
    {
        byte [] _result;
        Tracer.println (this._inner + ".getBytes (" + arg0 + ")");
        try {
            _result = this._inner.getBytes (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public byte [] getBytes (
        java.lang.String arg0)
    throws java.sql.SQLException
    {
        byte [] _result;
        Tracer.println (this._inner + ".getBytes (" + arg0 + ")");
        try {
            _result = this._inner.getBytes (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.sql.Array getArray (
        int arg0)
    throws java.sql.SQLException
    {
        java.sql.Array _result;
        Tracer.println (this._inner + ".getArray (" + arg0 + ")");
        try {
            _result = this._inner.getArray (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.sql.Array getArray (
        java.lang.String arg0)
    throws java.sql.SQLException
    {
        java.sql.Array _result;
        Tracer.println (this._inner + ".getArray (" + arg0 + ")");
        try {
            _result = this._inner.getArray (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.net.URL getURL (
        int arg0)
    throws java.sql.SQLException
    {
        java.net.URL _result;
        Tracer.println (this._inner + ".getURL (" + arg0 + ")");
        try {
            _result = this._inner.getURL (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.net.URL getURL (
        java.lang.String arg0)
    throws java.sql.SQLException
    {
        java.net.URL _result;
        Tracer.println (this._inner + ".getURL (" + arg0 + ")");
        try {
            _result = this._inner.getURL (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public boolean next ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".next (" + ")");
        try {
            _result = this._inner.next ();
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public int getType ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getType (" + ")");
        try {
            _result = this._inner.getType ();
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public boolean previous ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".previous (" + ")");
        try {
            _result = this._inner.previous ();
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public void close ()
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".close (" + ")");
        try {
            this._inner.close ();
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public java.sql.Ref getRef (
        java.lang.String arg0)
    throws java.sql.SQLException
    {
        java.sql.Ref _result;
        Tracer.println (this._inner + ".getRef (" + arg0 + ")");
        try {
            _result = this._inner.getRef (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.sql.Ref getRef (
        int arg0)
    throws java.sql.SQLException
    {
        java.sql.Ref _result;
        Tracer.println (this._inner + ".getRef (" + arg0 + ")");
        try {
            _result = this._inner.getRef (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.sql.Date getDate (
        java.lang.String arg0,
        java.util.Calendar arg1)
    throws java.sql.SQLException
    {
        java.sql.Date _result;
        Tracer.println (this._inner + ".getDate (" + arg0 + ", " + arg1 + ")");
        try {
            _result = this._inner.getDate (arg0, arg1);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.sql.Date getDate (
        int arg0)
    throws java.sql.SQLException
    {
        java.sql.Date _result;
        Tracer.println (this._inner + ".getDate (" + arg0 + ")");
        try {
            _result = this._inner.getDate (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.sql.Date getDate (
        int arg0,
        java.util.Calendar arg1)
    throws java.sql.SQLException
    {
        java.sql.Date _result;
        Tracer.println (this._inner + ".getDate (" + arg0 + ", " + arg1 + ")");
        try {
            _result = this._inner.getDate (arg0, arg1);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.sql.Date getDate (
        java.lang.String arg0)
    throws java.sql.SQLException
    {
        java.sql.Date _result;
        Tracer.println (this._inner + ".getDate (" + arg0 + ")");
        try {
            _result = this._inner.getDate (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.sql.Time getTime (
        int arg0,
        java.util.Calendar arg1)
    throws java.sql.SQLException
    {
        java.sql.Time _result;
        Tracer.println (this._inner + ".getTime (" + arg0 + ", " + arg1 + ")");
        try {
            _result = this._inner.getTime (arg0, arg1);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.sql.Time getTime (
        java.lang.String arg0,
        java.util.Calendar arg1)
    throws java.sql.SQLException
    {
        java.sql.Time _result;
        Tracer.println (this._inner + ".getTime (" + arg0 + ", " + arg1 + ")");
        try {
            _result = this._inner.getTime (arg0, arg1);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.sql.Time getTime (
        java.lang.String arg0)
    throws java.sql.SQLException
    {
        java.sql.Time _result;
        Tracer.println (this._inner + ".getTime (" + arg0 + ")");
        try {
            _result = this._inner.getTime (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.sql.Time getTime (
        int arg0)
    throws java.sql.SQLException
    {
        java.sql.Time _result;
        Tracer.println (this._inner + ".getTime (" + arg0 + ")");
        try {
            _result = this._inner.getTime (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.io.InputStream getBinaryStream (
        java.lang.String arg0)
    throws java.sql.SQLException
    {
        java.io.InputStream _result;
        Tracer.println (this._inner + ".getBinaryStream (" + arg0 + ")");
        try {
            _result = this._inner.getBinaryStream (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.io.InputStream getBinaryStream (
        int arg0)
    throws java.sql.SQLException
    {
        java.io.InputStream _result;
        Tracer.println (this._inner + ".getBinaryStream (" + arg0 + ")");
        try {
            _result = this._inner.getBinaryStream (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.math.BigDecimal getBigDecimal (
        java.lang.String arg0)
    throws java.sql.SQLException
    {
        java.math.BigDecimal _result;
        Tracer.println (this._inner + ".getBigDecimal (" + arg0 + ")");
        try {
            _result = this._inner.getBigDecimal (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.math.BigDecimal getBigDecimal (
        int arg0,
        int arg1)
    throws java.sql.SQLException
    {
        java.math.BigDecimal _result;
        Tracer.println (this._inner + ".getBigDecimal (" + arg0 + ", " + arg1 + ")");
        try {
            _result = this._inner.getBigDecimal (arg0, arg1);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.math.BigDecimal getBigDecimal (
        java.lang.String arg0,
        int arg1)
    throws java.sql.SQLException
    {
        java.math.BigDecimal _result;
        Tracer.println (this._inner + ".getBigDecimal (" + arg0 + ", " + arg1 + ")");
        try {
            _result = this._inner.getBigDecimal (arg0, arg1);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.math.BigDecimal getBigDecimal (
        int arg0)
    throws java.sql.SQLException
    {
        java.math.BigDecimal _result;
        Tracer.println (this._inner + ".getBigDecimal (" + arg0 + ")");
        try {
            _result = this._inner.getBigDecimal (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.sql.Blob getBlob (
        int arg0)
    throws java.sql.SQLException
    {
        java.sql.Blob _result;
        Tracer.println (this._inner + ".getBlob (" + arg0 + ")");
        try {
            _result = this._inner.getBlob (arg0);
            Tracer.println ("=> " + _result);
            if (_result != null) { 
              _result = com.sap.dbtech.jdbc.trace.Blob.createNew (_result);
            }
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.sql.Blob getBlob (
        java.lang.String arg0)
    throws java.sql.SQLException
    {
        java.sql.Blob _result;
        Tracer.println (this._inner + ".getBlob (" + arg0 + ")");
        try {
            _result = this._inner.getBlob (arg0);
            Tracer.println ("=> " + _result);
            if (_result != null) { 
              _result = com.sap.dbtech.jdbc.trace.Blob.createNew (_result);
            }
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.sql.Clob getClob (
        int arg0)
    throws java.sql.SQLException
    {
        java.sql.Clob _result;
        Tracer.println (this._inner + ".getClob (" + arg0 + ")");
        try {
            _result = this._inner.getClob (arg0);
            Tracer.println ("=> " + _result);
            if (_result != null) { 
              _result = com.sap.dbtech.jdbc.trace.Clob.createNew (_result);
            }
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.sql.Clob getClob (
        java.lang.String arg0)
    throws java.sql.SQLException
    {
        java.sql.Clob _result;
        Tracer.println (this._inner + ".getClob (" + arg0 + ")");
        try {
            _result = this._inner.getClob (arg0);
            Tracer.println ("=> " + _result);
            if (_result != null) { 
              _result = com.sap.dbtech.jdbc.trace.Clob.createNew (_result);
            }
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.lang.String getString (
        int arg0)
    throws java.sql.SQLException
    {
        java.lang.String _result;
        Tracer.println (this._inner + ".getString (" + arg0 + ")");
        try {
            _result = this._inner.getString (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.lang.String getString (
        java.lang.String arg0)
    throws java.sql.SQLException
    {
        java.lang.String _result;
        Tracer.println (this._inner + ".getString (" + arg0 + ")");
        try {
            _result = this._inner.getString (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.sql.Timestamp getTimestamp (
        java.lang.String arg0,
        java.util.Calendar arg1)
    throws java.sql.SQLException
    {
        java.sql.Timestamp _result;
        Tracer.println (this._inner + ".getTimestamp (" + arg0 + ", " + arg1 + ")");
        try {
            _result = this._inner.getTimestamp (arg0, arg1);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.sql.Timestamp getTimestamp (
        int arg0,
        java.util.Calendar arg1)
    throws java.sql.SQLException
    {
        java.sql.Timestamp _result;
        Tracer.println (this._inner + ".getTimestamp (" + arg0 + ", " + arg1 + ")");
        try {
            _result = this._inner.getTimestamp (arg0, arg1);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.sql.Timestamp getTimestamp (
        int arg0)
    throws java.sql.SQLException
    {
        java.sql.Timestamp _result;
        Tracer.println (this._inner + ".getTimestamp (" + arg0 + ")");
        try {
            _result = this._inner.getTimestamp (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.sql.Timestamp getTimestamp (
        java.lang.String arg0)
    throws java.sql.SQLException
    {
        java.sql.Timestamp _result;
        Tracer.println (this._inner + ".getTimestamp (" + arg0 + ")");
        try {
            _result = this._inner.getTimestamp (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public boolean wasNull ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".wasNull (" + ")");
        try {
            _result = this._inner.wasNull ();
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.sql.ResultSetMetaData getMetaData ()
    throws java.sql.SQLException
    {
        java.sql.ResultSetMetaData _result;
        Tracer.println (this._inner + ".getMetaData (" + ")");
        try {
            _result = this._inner.getMetaData ();
            Tracer.println ("=> " + _result);
            if (_result != null) { 
              _result = com.sap.dbtech.jdbc.trace.ResultSetMetaData.createNew (_result);
            }
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public void clearWarnings ()
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".clearWarnings (" + ")");
        try {
            this._inner.clearWarnings ();
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public int getFetchDirection ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getFetchDirection (" + ")");
        try {
            _result = this._inner.getFetchDirection ();
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public int getFetchSize ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getFetchSize (" + ")");
        try {
            _result = this._inner.getFetchSize ();
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.sql.SQLWarning getWarnings ()
    throws java.sql.SQLException
    {
        java.sql.SQLWarning _result;
        Tracer.println (this._inner + ".getWarnings (" + ")");
        try {
            _result = this._inner.getWarnings ();
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public void setFetchDirection (
        int arg0)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setFetchDirection (" + arg0 + ")");
        try {
            this._inner.setFetchDirection (arg0);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void setFetchSize (
        int arg0)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setFetchSize (" + arg0 + ")");
        try {
            this._inner.setFetchSize (arg0);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateTime (
        java.lang.String arg0,
        java.sql.Time arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateTime (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.updateTime (arg0, arg1);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateTime (
        int arg0,
        java.sql.Time arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateTime (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.updateTime (arg0, arg1);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public java.io.InputStream getAsciiStream (
        java.lang.String arg0)
    throws java.sql.SQLException
    {
        java.io.InputStream _result;
        Tracer.println (this._inner + ".getAsciiStream (" + arg0 + ")");
        try {
            _result = this._inner.getAsciiStream (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.io.InputStream getAsciiStream (
        int arg0)
    throws java.sql.SQLException
    {
        java.io.InputStream _result;
        Tracer.println (this._inner + ".getAsciiStream (" + arg0 + ")");
        try {
            _result = this._inner.getAsciiStream (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.io.Reader getCharacterStream (
        java.lang.String arg0)
    throws java.sql.SQLException
    {
        java.io.Reader _result;
        Tracer.println (this._inner + ".getCharacterStream (" + arg0 + ")");
        try {
            _result = this._inner.getCharacterStream (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.io.Reader getCharacterStream (
        int arg0)
    throws java.sql.SQLException
    {
        java.io.Reader _result;
        Tracer.println (this._inner + ".getCharacterStream (" + arg0 + ")");
        try {
            _result = this._inner.getCharacterStream (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public boolean absolute (
        int arg0)
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".absolute (" + arg0 + ")");
        try {
            _result = this._inner.absolute (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public void afterLast ()
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".afterLast (" + ")");
        try {
            this._inner.afterLast ();
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void beforeFirst ()
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".beforeFirst (" + ")");
        try {
            this._inner.beforeFirst ();
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void cancelRowUpdates ()
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".cancelRowUpdates (" + ")");
        try {
            this._inner.cancelRowUpdates ();
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void deleteRow ()
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".deleteRow (" + ")");
        try {
            this._inner.deleteRow ();
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public int findColumn (
        java.lang.String arg0)
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".findColumn (" + arg0 + ")");
        try {
            _result = this._inner.findColumn (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public boolean first ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".first (" + ")");
        try {
            _result = this._inner.first ();
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public int getConcurrency ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getConcurrency (" + ")");
        try {
            _result = this._inner.getConcurrency ();
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.lang.String getCursorName ()
    throws java.sql.SQLException
    {
        java.lang.String _result;
        Tracer.println (this._inner + ".getCursorName (" + ")");
        try {
            _result = this._inner.getCursorName ();
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public int getRow ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getRow (" + ")");
        try {
            _result = this._inner.getRow ();
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.sql.Statement getStatement ()
    throws java.sql.SQLException
    {
        java.sql.Statement _result;
        Tracer.println (this._inner + ".getStatement (" + ")");
        try {
            _result = this._inner.getStatement ();
            Tracer.println ("=> " + _result);
            if (_result != null) { 
              _result = com.sap.dbtech.jdbc.trace.Statement.createNew (_result);
            }
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.io.InputStream getUnicodeStream (
        java.lang.String arg0)
    throws java.sql.SQLException
    {
        java.io.InputStream _result;
        Tracer.println (this._inner + ".getUnicodeStream (" + arg0 + ")");
        try {
            _result = this._inner.getUnicodeStream (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public java.io.InputStream getUnicodeStream (
        int arg0)
    throws java.sql.SQLException
    {
        java.io.InputStream _result;
        Tracer.println (this._inner + ".getUnicodeStream (" + arg0 + ")");
        try {
            _result = this._inner.getUnicodeStream (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public void insertRow ()
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".insertRow (" + ")");
        try {
            this._inner.insertRow ();
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public boolean isAfterLast ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".isAfterLast (" + ")");
        try {
            _result = this._inner.isAfterLast ();
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public boolean isBeforeFirst ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".isBeforeFirst (" + ")");
        try {
            _result = this._inner.isBeforeFirst ();
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public boolean isFirst ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".isFirst (" + ")");
        try {
            _result = this._inner.isFirst ();
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public boolean isLast ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".isLast (" + ")");
        try {
            _result = this._inner.isLast ();
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public boolean last ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".last (" + ")");
        try {
            _result = this._inner.last ();
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public void moveToCurrentRow ()
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".moveToCurrentRow (" + ")");
        try {
            this._inner.moveToCurrentRow ();
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void moveToInsertRow ()
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".moveToInsertRow (" + ")");
        try {
            this._inner.moveToInsertRow ();
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void refreshRow ()
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".refreshRow (" + ")");
        try {
            this._inner.refreshRow ();
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public boolean relative (
        int arg0)
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".relative (" + arg0 + ")");
        try {
            _result = this._inner.relative (arg0);
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public boolean rowDeleted ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".rowDeleted (" + ")");
        try {
            _result = this._inner.rowDeleted ();
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public boolean rowInserted ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".rowInserted (" + ")");
        try {
            _result = this._inner.rowInserted ();
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public boolean rowUpdated ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".rowUpdated (" + ")");
        try {
            _result = this._inner.rowUpdated ();
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
        return _result;
    }

    public void updateArray (
        int arg0,
        java.sql.Array arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateArray (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.updateArray (arg0, arg1);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateArray (
        java.lang.String arg0,
        java.sql.Array arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateArray (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.updateArray (arg0, arg1);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateAsciiStream (
        int arg0,
        java.io.InputStream arg1,
        int arg2)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateAsciiStream (" + arg0 + ", " + arg1 + ", " + arg2 + ")");
        try {
            this._inner.updateAsciiStream (arg0, arg1, arg2);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateAsciiStream (
        java.lang.String arg0,
        java.io.InputStream arg1,
        int arg2)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateAsciiStream (" + arg0 + ", " + arg1 + ", " + arg2 + ")");
        try {
            this._inner.updateAsciiStream (arg0, arg1, arg2);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateBigDecimal (
        int arg0,
        java.math.BigDecimal arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateBigDecimal (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.updateBigDecimal (arg0, arg1);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateBigDecimal (
        java.lang.String arg0,
        java.math.BigDecimal arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateBigDecimal (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.updateBigDecimal (arg0, arg1);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateBinaryStream (
        java.lang.String arg0,
        java.io.InputStream arg1,
        int arg2)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateBinaryStream (" + arg0 + ", " + arg1 + ", " + arg2 + ")");
        try {
            this._inner.updateBinaryStream (arg0, arg1, arg2);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateBinaryStream (
        int arg0,
        java.io.InputStream arg1,
        int arg2)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateBinaryStream (" + arg0 + ", " + arg1 + ", " + arg2 + ")");
        try {
            this._inner.updateBinaryStream (arg0, arg1, arg2);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateBlob (
        java.lang.String arg0,
        java.sql.Blob arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateBlob (" + arg0 + ", " + com.sap.dbtech.jdbc.trace.Blob.getInner(arg1) + ")");
        try {
            this._inner.updateBlob (arg0, com.sap.dbtech.jdbc.trace.Blob.getInner(arg1));
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateBlob (
        int arg0,
        java.sql.Blob arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateBlob (" + arg0 + ", " + com.sap.dbtech.jdbc.trace.Blob.getInner(arg1) + ")");
        try {
            this._inner.updateBlob (arg0, com.sap.dbtech.jdbc.trace.Blob.getInner(arg1));
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateBoolean (
        java.lang.String arg0,
        boolean arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateBoolean (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.updateBoolean (arg0, arg1);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateBoolean (
        int arg0,
        boolean arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateBoolean (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.updateBoolean (arg0, arg1);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateByte (
        java.lang.String arg0,
        byte arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateByte (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.updateByte (arg0, arg1);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateByte (
        int arg0,
        byte arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateByte (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.updateByte (arg0, arg1);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateBytes (
        int arg0,
        byte [] arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateBytes (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.updateBytes (arg0, arg1);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateBytes (
        java.lang.String arg0,
        byte [] arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateBytes (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.updateBytes (arg0, arg1);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateCharacterStream (
        int arg0,
        java.io.Reader arg1,
        int arg2)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateCharacterStream (" + arg0 + ", " + arg1 + ", " + arg2 + ")");
        try {
            this._inner.updateCharacterStream (arg0, arg1, arg2);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateCharacterStream (
        java.lang.String arg0,
        java.io.Reader arg1,
        int arg2)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateCharacterStream (" + arg0 + ", " + arg1 + ", " + arg2 + ")");
        try {
            this._inner.updateCharacterStream (arg0, arg1, arg2);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateClob (
        int arg0,
        java.sql.Clob arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateClob (" + arg0 + ", " + com.sap.dbtech.jdbc.trace.Clob.getInner(arg1) + ")");
        try {
            this._inner.updateClob (arg0, com.sap.dbtech.jdbc.trace.Clob.getInner(arg1));
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateClob (
        java.lang.String arg0,
        java.sql.Clob arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateClob (" + arg0 + ", " + com.sap.dbtech.jdbc.trace.Clob.getInner(arg1) + ")");
        try {
            this._inner.updateClob (arg0, com.sap.dbtech.jdbc.trace.Clob.getInner(arg1));
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateDate (
        java.lang.String arg0,
        java.sql.Date arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateDate (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.updateDate (arg0, arg1);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateDate (
        int arg0,
        java.sql.Date arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateDate (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.updateDate (arg0, arg1);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateDouble (
        java.lang.String arg0,
        double arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateDouble (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.updateDouble (arg0, arg1);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateDouble (
        int arg0,
        double arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateDouble (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.updateDouble (arg0, arg1);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateFloat (
        int arg0,
        float arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateFloat (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.updateFloat (arg0, arg1);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateFloat (
        java.lang.String arg0,
        float arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateFloat (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.updateFloat (arg0, arg1);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateInt (
        int arg0,
        int arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateInt (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.updateInt (arg0, arg1);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateInt (
        java.lang.String arg0,
        int arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateInt (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.updateInt (arg0, arg1);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateLong (
        int arg0,
        long arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateLong (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.updateLong (arg0, arg1);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateLong (
        java.lang.String arg0,
        long arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateLong (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.updateLong (arg0, arg1);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateNull (
        int arg0)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateNull (" + arg0 + ")");
        try {
            this._inner.updateNull (arg0);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateNull (
        java.lang.String arg0)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateNull (" + arg0 + ")");
        try {
            this._inner.updateNull (arg0);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateObject (
        java.lang.String arg0,
        java.lang.Object arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateObject (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.updateObject (arg0, arg1);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateObject (
        int arg0,
        java.lang.Object arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateObject (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.updateObject (arg0, arg1);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateObject (
        int arg0,
        java.lang.Object arg1,
        int arg2)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateObject (" + arg0 + ", " + arg1 + ", " + arg2 + ")");
        try {
            this._inner.updateObject (arg0, arg1, arg2);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateObject (
        java.lang.String arg0,
        java.lang.Object arg1,
        int arg2)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateObject (" + arg0 + ", " + arg1 + ", " + arg2 + ")");
        try {
            this._inner.updateObject (arg0, arg1, arg2);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateRef (
        java.lang.String arg0,
        java.sql.Ref arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateRef (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.updateRef (arg0, arg1);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateRef (
        int arg0,
        java.sql.Ref arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateRef (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.updateRef (arg0, arg1);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateRow ()
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateRow (" + ")");
        try {
            this._inner.updateRow ();
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateShort (
        java.lang.String arg0,
        short arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateShort (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.updateShort (arg0, arg1);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateShort (
        int arg0,
        short arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateShort (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.updateShort (arg0, arg1);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateString (
        int arg0,
        java.lang.String arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateString (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.updateString (arg0, arg1);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateString (
        java.lang.String arg0,
        java.lang.String arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateString (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.updateString (arg0, arg1);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateTimestamp (
        int arg0,
        java.sql.Timestamp arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateTimestamp (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.updateTimestamp (arg0, arg1);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void updateTimestamp (
        java.lang.String arg0,
        java.sql.Timestamp arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".updateTimestamp (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.updateTimestamp (arg0, arg1);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }


}