package com.sap.dbtech.jdbc.trace;


import com.sap.dbtech.util.Tracer;

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

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

    public void setBoolean (
        int arg0,
        boolean arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setBoolean (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.setBoolean (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 setByte (
        int arg0,
        byte arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setByte (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.setByte (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 setDouble (
        int arg0,
        double arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setDouble (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.setDouble (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 setFloat (
        int arg0,
        float arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setFloat (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.setFloat (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 setInt (
        int arg0,
        int arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setInt (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.setInt (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 setLong (
        int arg0,
        long arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setLong (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.setLong (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 setShort (
        int arg0,
        short arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setShort (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.setShort (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 setTimestamp (
        int arg0,
        java.sql.Timestamp arg1,
        java.util.Calendar arg2)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setTimestamp (" + arg0 + ", " + arg1 + ", " + arg2 + ")");
        try {
            this._inner.setTimestamp (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 setTimestamp (
        int arg0,
        java.sql.Timestamp arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setTimestamp (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.setTimestamp (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 setURL (
        int arg0,
        java.net.URL arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setURL (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.setURL (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 setTime (
        int arg0,
        java.sql.Time arg1,
        java.util.Calendar arg2)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setTime (" + arg0 + ", " + arg1 + ", " + arg2 + ")");
        try {
            this._inner.setTime (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 setTime (
        int arg0,
        java.sql.Time arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setTime (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.setTime (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 boolean execute ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".execute (" + ")");
        try {
            _result = this._inner.execute ();
            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 setBinaryStream (
        int arg0,
        java.io.InputStream arg1,
        int arg2)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setBinaryStream (" + arg0 + ", " + arg1 + ", " + arg2 + ")");
        try {
            this._inner.setBinaryStream (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 setBytes (
        int arg0,
        byte [] arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setBytes (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.setBytes (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 setAsciiStream (
        int arg0,
        java.io.InputStream arg1,
        int arg2)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setAsciiStream (" + arg0 + ", " + arg1 + ", " + arg2 + ")");
        try {
            this._inner.setAsciiStream (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 setBigDecimal (
        int arg0,
        java.math.BigDecimal arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setBigDecimal (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.setBigDecimal (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 setCharacterStream (
        int arg0,
        java.io.Reader arg1,
        int arg2)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setCharacterStream (" + arg0 + ", " + arg1 + ", " + arg2 + ")");
        try {
            this._inner.setCharacterStream (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 setDate (
        int arg0,
        java.sql.Date arg1,
        java.util.Calendar arg2)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setDate (" + arg0 + ", " + arg1 + ", " + arg2 + ")");
        try {
            this._inner.setDate (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 setDate (
        int arg0,
        java.sql.Date arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setDate (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.setDate (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 setNull (
        int arg0,
        int arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setNull (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.setNull (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 setNull (
        int arg0,
        int arg1,
        java.lang.String arg2)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setNull (" + arg0 + ", " + arg1 + ", " + arg2 + ")");
        try {
            this._inner.setNull (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 setObject (
        int arg0,
        java.lang.Object arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setObject (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.setObject (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 setObject (
        int arg0,
        java.lang.Object arg1,
        int arg2)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setObject (" + arg0 + ", " + arg1 + ", " + arg2 + ")");
        try {
            this._inner.setObject (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 setObject (
        int arg0,
        java.lang.Object arg1,
        int arg2,
        int arg3)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setObject (" + arg0 + ", " + arg1 + ", " + arg2 + ", " + arg3 + ")");
        try {
            this._inner.setObject (arg0, arg1, arg2, arg3);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void setString (
        int arg0,
        java.lang.String arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setString (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.setString (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 addBatch ()
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".addBatch (" + ")");
        try {
            this._inner.addBatch ();
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

    public void clearParameters ()
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".clearParameters (" + ")");
        try {
            this._inner.clearParameters ();
        }
        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.ResultSet executeQuery ()
    throws java.sql.SQLException
    {
        java.sql.ResultSet _result;
        Tracer.println (this._inner + ".executeQuery (" + ")");
        try {
            _result = this._inner.executeQuery ();
            Tracer.println ("=> " + _result);
            if (_result != null) { 
              _result = com.sap.dbtech.jdbc.trace.ResultSet.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 int executeUpdate ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".executeUpdate (" + ")");
        try {
            _result = this._inner.executeUpdate ();
            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 java.sql.ParameterMetaData getParameterMetaData ()
    throws java.sql.SQLException
    {
        java.sql.ParameterMetaData _result;
        Tracer.println (this._inner + ".getParameterMetaData (" + ")");
        try {
            _result = this._inner.getParameterMetaData ();
            Tracer.println ("=> " + _result);
            if (_result != null) { 
              _result = com.sap.dbtech.jdbc.trace.ParameterMetaData.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 setArray (
        int arg0,
        java.sql.Array arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setArray (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.setArray (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 setBlob (
        int arg0,
        java.sql.Blob arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setBlob (" + arg0 + ", " + com.sap.dbtech.jdbc.trace.Blob.getInner(arg1) + ")");
        try {
            this._inner.setBlob (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 setClob (
        int arg0,
        java.sql.Clob arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setClob (" + arg0 + ", " + com.sap.dbtech.jdbc.trace.Clob.getInner(arg1) + ")");
        try {
            this._inner.setClob (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 setRef (
        int arg0,
        java.sql.Ref arg1)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setRef (" + arg0 + ", " + arg1 + ")");
        try {
            this._inner.setRef (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 setUnicodeStream (
        int arg0,
        java.io.InputStream arg1,
        int arg2)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setUnicodeStream (" + arg0 + ", " + arg1 + ", " + arg2 + ")");
        try {
            this._inner.setUnicodeStream (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 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 boolean execute (
        java.lang.String arg0,
        int arg1)
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".execute (" + arg0 + ", " + arg1 + ")");
        try {
            _result = this._inner.execute (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 execute (
        java.lang.String arg0,
        java.lang.String [] arg1)
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".execute (" + arg0 + ", " + arg1 + ")");
        try {
            _result = this._inner.execute (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 execute (
        java.lang.String arg0,
        int [] arg1)
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".execute (" + arg0 + ", " + arg1 + ")");
        try {
            _result = this._inner.execute (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 execute (
        java.lang.String arg0)
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".execute (" + arg0 + ")");
        try {
            _result = this._inner.execute (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 addBatch (
        java.lang.String arg0)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".addBatch (" + arg0 + ")");
        try {
            this._inner.addBatch (arg0);
        }
        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.ResultSet executeQuery (
        java.lang.String arg0)
    throws java.sql.SQLException
    {
        java.sql.ResultSet _result;
        Tracer.println (this._inner + ".executeQuery (" + arg0 + ")");
        try {
            _result = this._inner.executeQuery (arg0);
            Tracer.println ("=> " + _result);
            if (_result != null) { 
              _result = com.sap.dbtech.jdbc.trace.ResultSet.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 int executeUpdate (
        java.lang.String arg0,
        int arg1)
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".executeUpdate (" + arg0 + ", " + arg1 + ")");
        try {
            _result = this._inner.executeUpdate (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 int executeUpdate (
        java.lang.String arg0,
        int [] arg1)
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".executeUpdate (" + arg0 + ", " + arg1 + ")");
        try {
            _result = this._inner.executeUpdate (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 int executeUpdate (
        java.lang.String arg0,
        java.lang.String [] arg1)
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".executeUpdate (" + arg0 + ", " + arg1 + ")");
        try {
            _result = this._inner.executeUpdate (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 int executeUpdate (
        java.lang.String arg0)
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".executeUpdate (" + arg0 + ")");
        try {
            _result = this._inner.executeUpdate (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 cancel ()
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".cancel (" + ")");
        try {
            this._inner.cancel ();
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }

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

    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 [] executeBatch ()
    throws java.sql.SQLException
    {
        int [] _result;
        Tracer.println (this._inner + ".executeBatch (" + ")");
        try {
            _result = this._inner.executeBatch ();
            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.Connection getConnection ()
    throws java.sql.SQLException
    {
        java.sql.Connection _result;
        Tracer.println (this._inner + ".getConnection (" + ")");
        try {
            _result = this._inner.getConnection ();
            Tracer.println ("=> " + _result);
            if (_result != null) { 
              _result = com.sap.dbtech.jdbc.trace.Connection.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 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.ResultSet getGeneratedKeys ()
    throws java.sql.SQLException
    {
        java.sql.ResultSet _result;
        Tracer.println (this._inner + ".getGeneratedKeys (" + ")");
        try {
            _result = this._inner.getGeneratedKeys ();
            Tracer.println ("=> " + _result);
            if (_result != null) { 
              _result = com.sap.dbtech.jdbc.trace.ResultSet.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 int getMaxFieldSize ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getMaxFieldSize (" + ")");
        try {
            _result = this._inner.getMaxFieldSize ();
            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 getMaxRows ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getMaxRows (" + ")");
        try {
            _result = this._inner.getMaxRows ();
            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 getMoreResults ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".getMoreResults (" + ")");
        try {
            _result = this._inner.getMoreResults ();
            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 getMoreResults (
        int arg0)
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".getMoreResults (" + arg0 + ")");
        try {
            _result = this._inner.getMoreResults (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 getQueryTimeout ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getQueryTimeout (" + ")");
        try {
            _result = this._inner.getQueryTimeout ();
            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.ResultSet getResultSet ()
    throws java.sql.SQLException
    {
        java.sql.ResultSet _result;
        Tracer.println (this._inner + ".getResultSet (" + ")");
        try {
            _result = this._inner.getResultSet ();
            Tracer.println ("=> " + _result);
            if (_result != null) { 
              _result = com.sap.dbtech.jdbc.trace.ResultSet.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 int getResultSetConcurrency ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getResultSetConcurrency (" + ")");
        try {
            _result = this._inner.getResultSetConcurrency ();
            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 getResultSetHoldability ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getResultSetHoldability (" + ")");
        try {
            _result = this._inner.getResultSetHoldability ();
            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 getResultSetType ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getResultSetType (" + ")");
        try {
            _result = this._inner.getResultSetType ();
            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 getUpdateCount ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getUpdateCount (" + ")");
        try {
            _result = this._inner.getUpdateCount ();
            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 setCursorName (
        java.lang.String arg0)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setCursorName (" + arg0 + ")");
        try {
            this._inner.setCursorName (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 setEscapeProcessing (
        boolean arg0)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setEscapeProcessing (" + arg0 + ")");
        try {
            this._inner.setEscapeProcessing (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 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 setMaxFieldSize (
        int arg0)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setMaxFieldSize (" + arg0 + ")");
        try {
            this._inner.setMaxFieldSize (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 setMaxRows (
        int arg0)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setMaxRows (" + arg0 + ")");
        try {
            this._inner.setMaxRows (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 setQueryTimeout (
        int arg0)
    throws java.sql.SQLException
    {
        Tracer.println (this._inner + ".setQueryTimeout (" + arg0 + ")");
        try {
            this._inner.setQueryTimeout (arg0);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        catch (java.sql.SQLException _exc0) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc0);
            throw _exc0;
        }
    }


}