package com.sap.dbtech.jdbc.trace;


import com.sap.dbtech.util.Tracer;

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

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

    public java.lang.String getURL ()
    throws java.sql.SQLException
    {
        java.lang.String _result;
        Tracer.println (this._inner + ".getURL (" + ")");
        try {
            _result = this._inner.getURL ();
            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 isReadOnly ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".isReadOnly (" + ")");
        try {
            _result = this._inner.isReadOnly ();
            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 getAttributes (
        java.lang.String arg0,
        java.lang.String arg1,
        java.lang.String arg2,
        java.lang.String arg3)
    throws java.sql.SQLException
    {
        java.sql.ResultSet _result;
        Tracer.println (this._inner + ".getAttributes (" + arg0 + ", " + arg1 + ", " + arg2 + ", " + arg3 + ")");
        try {
            _result = this._inner.getAttributes (arg0, arg1, arg2, arg3);
            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 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 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 boolean allProceduresAreCallable ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".allProceduresAreCallable (" + ")");
        try {
            _result = this._inner.allProceduresAreCallable ();
            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 allTablesAreSelectable ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".allTablesAreSelectable (" + ")");
        try {
            _result = this._inner.allTablesAreSelectable ();
            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 dataDefinitionCausesTransactionCommit ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".dataDefinitionCausesTransactionCommit (" + ")");
        try {
            _result = this._inner.dataDefinitionCausesTransactionCommit ();
            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 dataDefinitionIgnoredInTransactions ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".dataDefinitionIgnoredInTransactions (" + ")");
        try {
            _result = this._inner.dataDefinitionIgnoredInTransactions ();
            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 deletesAreDetected (
        int arg0)
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".deletesAreDetected (" + arg0 + ")");
        try {
            _result = this._inner.deletesAreDetected (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 doesMaxRowSizeIncludeBlobs ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".doesMaxRowSizeIncludeBlobs (" + ")");
        try {
            _result = this._inner.doesMaxRowSizeIncludeBlobs ();
            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 getBestRowIdentifier (
        java.lang.String arg0,
        java.lang.String arg1,
        java.lang.String arg2,
        int arg3,
        boolean arg4)
    throws java.sql.SQLException
    {
        java.sql.ResultSet _result;
        Tracer.println (this._inner + ".getBestRowIdentifier (" + arg0 + ", " + arg1 + ", " + arg2 + ", " + arg3 + ", " + arg4 + ")");
        try {
            _result = this._inner.getBestRowIdentifier (arg0, arg1, arg2, arg3, arg4);
            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 java.lang.String getCatalogSeparator ()
    throws java.sql.SQLException
    {
        java.lang.String _result;
        Tracer.println (this._inner + ".getCatalogSeparator (" + ")");
        try {
            _result = this._inner.getCatalogSeparator ();
            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 getCatalogTerm ()
    throws java.sql.SQLException
    {
        java.lang.String _result;
        Tracer.println (this._inner + ".getCatalogTerm (" + ")");
        try {
            _result = this._inner.getCatalogTerm ();
            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 getCatalogs ()
    throws java.sql.SQLException
    {
        java.sql.ResultSet _result;
        Tracer.println (this._inner + ".getCatalogs (" + ")");
        try {
            _result = this._inner.getCatalogs ();
            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 java.sql.ResultSet getColumnPrivileges (
        java.lang.String arg0,
        java.lang.String arg1,
        java.lang.String arg2,
        java.lang.String arg3)
    throws java.sql.SQLException
    {
        java.sql.ResultSet _result;
        Tracer.println (this._inner + ".getColumnPrivileges (" + arg0 + ", " + arg1 + ", " + arg2 + ", " + arg3 + ")");
        try {
            _result = this._inner.getColumnPrivileges (arg0, arg1, arg2, arg3);
            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 java.sql.ResultSet getColumns (
        java.lang.String arg0,
        java.lang.String arg1,
        java.lang.String arg2,
        java.lang.String arg3)
    throws java.sql.SQLException
    {
        java.sql.ResultSet _result;
        Tracer.println (this._inner + ".getColumns (" + arg0 + ", " + arg1 + ", " + arg2 + ", " + arg3 + ")");
        try {
            _result = this._inner.getColumns (arg0, arg1, arg2, arg3);
            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 java.sql.ResultSet getCrossReference (
        java.lang.String arg0,
        java.lang.String arg1,
        java.lang.String arg2,
        java.lang.String arg3,
        java.lang.String arg4,
        java.lang.String arg5)
    throws java.sql.SQLException
    {
        java.sql.ResultSet _result;
        Tracer.println (this._inner + ".getCrossReference (" + arg0 + ", " + arg1 + ", " + arg2 + ", " + arg3 + ", " + arg4 + ", " + arg5 + ")");
        try {
            _result = this._inner.getCrossReference (arg0, arg1, arg2, arg3, arg4, arg5);
            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 getDatabaseMajorVersion ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getDatabaseMajorVersion (" + ")");
        try {
            _result = this._inner.getDatabaseMajorVersion ();
            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 getDatabaseMinorVersion ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getDatabaseMinorVersion (" + ")");
        try {
            _result = this._inner.getDatabaseMinorVersion ();
            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 getDatabaseProductName ()
    throws java.sql.SQLException
    {
        java.lang.String _result;
        Tracer.println (this._inner + ".getDatabaseProductName (" + ")");
        try {
            _result = this._inner.getDatabaseProductName ();
            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 getDatabaseProductVersion ()
    throws java.sql.SQLException
    {
        java.lang.String _result;
        Tracer.println (this._inner + ".getDatabaseProductVersion (" + ")");
        try {
            _result = this._inner.getDatabaseProductVersion ();
            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 getDefaultTransactionIsolation ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getDefaultTransactionIsolation (" + ")");
        try {
            _result = this._inner.getDefaultTransactionIsolation ();
            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 getDriverMajorVersion ()
    {
        int _result;
        Tracer.println (this._inner + ".getDriverMajorVersion (" + ")");
        try {
            _result = this._inner.getDriverMajorVersion ();
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        return _result;
    }

    public int getDriverMinorVersion ()
    {
        int _result;
        Tracer.println (this._inner + ".getDriverMinorVersion (" + ")");
        try {
            _result = this._inner.getDriverMinorVersion ();
            Tracer.println ("=> " + _result);
        }
        catch (RuntimeException _exc) {
            Tracer.println (" <-!");
            Tracer.traceException (_exc);
            throw _exc;
        }
        return _result;
    }

    public java.lang.String getDriverName ()
    throws java.sql.SQLException
    {
        java.lang.String _result;
        Tracer.println (this._inner + ".getDriverName (" + ")");
        try {
            _result = this._inner.getDriverName ();
            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 getDriverVersion ()
    throws java.sql.SQLException
    {
        java.lang.String _result;
        Tracer.println (this._inner + ".getDriverVersion (" + ")");
        try {
            _result = this._inner.getDriverVersion ();
            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 getExportedKeys (
        java.lang.String arg0,
        java.lang.String arg1,
        java.lang.String arg2)
    throws java.sql.SQLException
    {
        java.sql.ResultSet _result;
        Tracer.println (this._inner + ".getExportedKeys (" + arg0 + ", " + arg1 + ", " + arg2 + ")");
        try {
            _result = this._inner.getExportedKeys (arg0, arg1, arg2);
            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 java.lang.String getExtraNameCharacters ()
    throws java.sql.SQLException
    {
        java.lang.String _result;
        Tracer.println (this._inner + ".getExtraNameCharacters (" + ")");
        try {
            _result = this._inner.getExtraNameCharacters ();
            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 getIdentifierQuoteString ()
    throws java.sql.SQLException
    {
        java.lang.String _result;
        Tracer.println (this._inner + ".getIdentifierQuoteString (" + ")");
        try {
            _result = this._inner.getIdentifierQuoteString ();
            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 getImportedKeys (
        java.lang.String arg0,
        java.lang.String arg1,
        java.lang.String arg2)
    throws java.sql.SQLException
    {
        java.sql.ResultSet _result;
        Tracer.println (this._inner + ".getImportedKeys (" + arg0 + ", " + arg1 + ", " + arg2 + ")");
        try {
            _result = this._inner.getImportedKeys (arg0, arg1, arg2);
            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 java.sql.ResultSet getIndexInfo (
        java.lang.String arg0,
        java.lang.String arg1,
        java.lang.String arg2,
        boolean arg3,
        boolean arg4)
    throws java.sql.SQLException
    {
        java.sql.ResultSet _result;
        Tracer.println (this._inner + ".getIndexInfo (" + arg0 + ", " + arg1 + ", " + arg2 + ", " + arg3 + ", " + arg4 + ")");
        try {
            _result = this._inner.getIndexInfo (arg0, arg1, arg2, arg3, arg4);
            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 getJDBCMajorVersion ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getJDBCMajorVersion (" + ")");
        try {
            _result = this._inner.getJDBCMajorVersion ();
            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 getJDBCMinorVersion ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getJDBCMinorVersion (" + ")");
        try {
            _result = this._inner.getJDBCMinorVersion ();
            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 getMaxBinaryLiteralLength ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getMaxBinaryLiteralLength (" + ")");
        try {
            _result = this._inner.getMaxBinaryLiteralLength ();
            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 getMaxCatalogNameLength ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getMaxCatalogNameLength (" + ")");
        try {
            _result = this._inner.getMaxCatalogNameLength ();
            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 getMaxCharLiteralLength ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getMaxCharLiteralLength (" + ")");
        try {
            _result = this._inner.getMaxCharLiteralLength ();
            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 getMaxColumnNameLength ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getMaxColumnNameLength (" + ")");
        try {
            _result = this._inner.getMaxColumnNameLength ();
            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 getMaxColumnsInGroupBy ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getMaxColumnsInGroupBy (" + ")");
        try {
            _result = this._inner.getMaxColumnsInGroupBy ();
            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 getMaxColumnsInIndex ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getMaxColumnsInIndex (" + ")");
        try {
            _result = this._inner.getMaxColumnsInIndex ();
            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 getMaxColumnsInOrderBy ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getMaxColumnsInOrderBy (" + ")");
        try {
            _result = this._inner.getMaxColumnsInOrderBy ();
            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 getMaxColumnsInSelect ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getMaxColumnsInSelect (" + ")");
        try {
            _result = this._inner.getMaxColumnsInSelect ();
            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 getMaxColumnsInTable ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getMaxColumnsInTable (" + ")");
        try {
            _result = this._inner.getMaxColumnsInTable ();
            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 getMaxConnections ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getMaxConnections (" + ")");
        try {
            _result = this._inner.getMaxConnections ();
            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 getMaxCursorNameLength ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getMaxCursorNameLength (" + ")");
        try {
            _result = this._inner.getMaxCursorNameLength ();
            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 getMaxIndexLength ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getMaxIndexLength (" + ")");
        try {
            _result = this._inner.getMaxIndexLength ();
            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 getMaxProcedureNameLength ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getMaxProcedureNameLength (" + ")");
        try {
            _result = this._inner.getMaxProcedureNameLength ();
            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 getMaxRowSize ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getMaxRowSize (" + ")");
        try {
            _result = this._inner.getMaxRowSize ();
            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 getMaxSchemaNameLength ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getMaxSchemaNameLength (" + ")");
        try {
            _result = this._inner.getMaxSchemaNameLength ();
            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 getMaxStatementLength ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getMaxStatementLength (" + ")");
        try {
            _result = this._inner.getMaxStatementLength ();
            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 getMaxStatements ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getMaxStatements (" + ")");
        try {
            _result = this._inner.getMaxStatements ();
            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 getMaxTableNameLength ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getMaxTableNameLength (" + ")");
        try {
            _result = this._inner.getMaxTableNameLength ();
            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 getMaxTablesInSelect ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getMaxTablesInSelect (" + ")");
        try {
            _result = this._inner.getMaxTablesInSelect ();
            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 getMaxUserNameLength ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getMaxUserNameLength (" + ")");
        try {
            _result = this._inner.getMaxUserNameLength ();
            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 getNumericFunctions ()
    throws java.sql.SQLException
    {
        java.lang.String _result;
        Tracer.println (this._inner + ".getNumericFunctions (" + ")");
        try {
            _result = this._inner.getNumericFunctions ();
            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 getPrimaryKeys (
        java.lang.String arg0,
        java.lang.String arg1,
        java.lang.String arg2)
    throws java.sql.SQLException
    {
        java.sql.ResultSet _result;
        Tracer.println (this._inner + ".getPrimaryKeys (" + arg0 + ", " + arg1 + ", " + arg2 + ")");
        try {
            _result = this._inner.getPrimaryKeys (arg0, arg1, arg2);
            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 java.sql.ResultSet getProcedureColumns (
        java.lang.String arg0,
        java.lang.String arg1,
        java.lang.String arg2,
        java.lang.String arg3)
    throws java.sql.SQLException
    {
        java.sql.ResultSet _result;
        Tracer.println (this._inner + ".getProcedureColumns (" + arg0 + ", " + arg1 + ", " + arg2 + ", " + arg3 + ")");
        try {
            _result = this._inner.getProcedureColumns (arg0, arg1, arg2, arg3);
            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 java.lang.String getProcedureTerm ()
    throws java.sql.SQLException
    {
        java.lang.String _result;
        Tracer.println (this._inner + ".getProcedureTerm (" + ")");
        try {
            _result = this._inner.getProcedureTerm ();
            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 getProcedures (
        java.lang.String arg0,
        java.lang.String arg1,
        java.lang.String arg2)
    throws java.sql.SQLException
    {
        java.sql.ResultSet _result;
        Tracer.println (this._inner + ".getProcedures (" + arg0 + ", " + arg1 + ", " + arg2 + ")");
        try {
            _result = this._inner.getProcedures (arg0, arg1, arg2);
            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 java.lang.String getSQLKeywords ()
    throws java.sql.SQLException
    {
        java.lang.String _result;
        Tracer.println (this._inner + ".getSQLKeywords (" + ")");
        try {
            _result = this._inner.getSQLKeywords ();
            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 getSQLStateType ()
    throws java.sql.SQLException
    {
        int _result;
        Tracer.println (this._inner + ".getSQLStateType (" + ")");
        try {
            _result = this._inner.getSQLStateType ();
            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 getSchemaTerm ()
    throws java.sql.SQLException
    {
        java.lang.String _result;
        Tracer.println (this._inner + ".getSchemaTerm (" + ")");
        try {
            _result = this._inner.getSchemaTerm ();
            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 getSchemas ()
    throws java.sql.SQLException
    {
        java.sql.ResultSet _result;
        Tracer.println (this._inner + ".getSchemas (" + ")");
        try {
            _result = this._inner.getSchemas ();
            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 java.lang.String getSearchStringEscape ()
    throws java.sql.SQLException
    {
        java.lang.String _result;
        Tracer.println (this._inner + ".getSearchStringEscape (" + ")");
        try {
            _result = this._inner.getSearchStringEscape ();
            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 getStringFunctions ()
    throws java.sql.SQLException
    {
        java.lang.String _result;
        Tracer.println (this._inner + ".getStringFunctions (" + ")");
        try {
            _result = this._inner.getStringFunctions ();
            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 getSuperTables (
        java.lang.String arg0,
        java.lang.String arg1,
        java.lang.String arg2)
    throws java.sql.SQLException
    {
        java.sql.ResultSet _result;
        Tracer.println (this._inner + ".getSuperTables (" + arg0 + ", " + arg1 + ", " + arg2 + ")");
        try {
            _result = this._inner.getSuperTables (arg0, arg1, arg2);
            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 java.sql.ResultSet getSuperTypes (
        java.lang.String arg0,
        java.lang.String arg1,
        java.lang.String arg2)
    throws java.sql.SQLException
    {
        java.sql.ResultSet _result;
        Tracer.println (this._inner + ".getSuperTypes (" + arg0 + ", " + arg1 + ", " + arg2 + ")");
        try {
            _result = this._inner.getSuperTypes (arg0, arg1, arg2);
            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 java.lang.String getSystemFunctions ()
    throws java.sql.SQLException
    {
        java.lang.String _result;
        Tracer.println (this._inner + ".getSystemFunctions (" + ")");
        try {
            _result = this._inner.getSystemFunctions ();
            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 getTablePrivileges (
        java.lang.String arg0,
        java.lang.String arg1,
        java.lang.String arg2)
    throws java.sql.SQLException
    {
        java.sql.ResultSet _result;
        Tracer.println (this._inner + ".getTablePrivileges (" + arg0 + ", " + arg1 + ", " + arg2 + ")");
        try {
            _result = this._inner.getTablePrivileges (arg0, arg1, arg2);
            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 java.sql.ResultSet getTableTypes ()
    throws java.sql.SQLException
    {
        java.sql.ResultSet _result;
        Tracer.println (this._inner + ".getTableTypes (" + ")");
        try {
            _result = this._inner.getTableTypes ();
            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 java.sql.ResultSet getTables (
        java.lang.String arg0,
        java.lang.String arg1,
        java.lang.String arg2,
        java.lang.String [] arg3)
    throws java.sql.SQLException
    {
        java.sql.ResultSet _result;
        Tracer.println (this._inner + ".getTables (" + arg0 + ", " + arg1 + ", " + arg2 + ", " + arg3 + ")");
        try {
            _result = this._inner.getTables (arg0, arg1, arg2, arg3);
            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 java.lang.String getTimeDateFunctions ()
    throws java.sql.SQLException
    {
        java.lang.String _result;
        Tracer.println (this._inner + ".getTimeDateFunctions (" + ")");
        try {
            _result = this._inner.getTimeDateFunctions ();
            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 getTypeInfo ()
    throws java.sql.SQLException
    {
        java.sql.ResultSet _result;
        Tracer.println (this._inner + ".getTypeInfo (" + ")");
        try {
            _result = this._inner.getTypeInfo ();
            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 java.sql.ResultSet getUDTs (
        java.lang.String arg0,
        java.lang.String arg1,
        java.lang.String arg2,
        int [] arg3)
    throws java.sql.SQLException
    {
        java.sql.ResultSet _result;
        Tracer.println (this._inner + ".getUDTs (" + arg0 + ", " + arg1 + ", " + arg2 + ", " + arg3 + ")");
        try {
            _result = this._inner.getUDTs (arg0, arg1, arg2, arg3);
            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 java.lang.String getUserName ()
    throws java.sql.SQLException
    {
        java.lang.String _result;
        Tracer.println (this._inner + ".getUserName (" + ")");
        try {
            _result = this._inner.getUserName ();
            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 getVersionColumns (
        java.lang.String arg0,
        java.lang.String arg1,
        java.lang.String arg2)
    throws java.sql.SQLException
    {
        java.sql.ResultSet _result;
        Tracer.println (this._inner + ".getVersionColumns (" + arg0 + ", " + arg1 + ", " + arg2 + ")");
        try {
            _result = this._inner.getVersionColumns (arg0, arg1, arg2);
            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 boolean insertsAreDetected (
        int arg0)
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".insertsAreDetected (" + arg0 + ")");
        try {
            _result = this._inner.insertsAreDetected (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 isCatalogAtStart ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".isCatalogAtStart (" + ")");
        try {
            _result = this._inner.isCatalogAtStart ();
            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 locatorsUpdateCopy ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".locatorsUpdateCopy (" + ")");
        try {
            _result = this._inner.locatorsUpdateCopy ();
            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 nullPlusNonNullIsNull ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".nullPlusNonNullIsNull (" + ")");
        try {
            _result = this._inner.nullPlusNonNullIsNull ();
            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 nullsAreSortedAtEnd ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".nullsAreSortedAtEnd (" + ")");
        try {
            _result = this._inner.nullsAreSortedAtEnd ();
            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 nullsAreSortedAtStart ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".nullsAreSortedAtStart (" + ")");
        try {
            _result = this._inner.nullsAreSortedAtStart ();
            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 nullsAreSortedHigh ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".nullsAreSortedHigh (" + ")");
        try {
            _result = this._inner.nullsAreSortedHigh ();
            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 nullsAreSortedLow ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".nullsAreSortedLow (" + ")");
        try {
            _result = this._inner.nullsAreSortedLow ();
            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 othersDeletesAreVisible (
        int arg0)
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".othersDeletesAreVisible (" + arg0 + ")");
        try {
            _result = this._inner.othersDeletesAreVisible (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 othersInsertsAreVisible (
        int arg0)
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".othersInsertsAreVisible (" + arg0 + ")");
        try {
            _result = this._inner.othersInsertsAreVisible (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 othersUpdatesAreVisible (
        int arg0)
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".othersUpdatesAreVisible (" + arg0 + ")");
        try {
            _result = this._inner.othersUpdatesAreVisible (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 ownDeletesAreVisible (
        int arg0)
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".ownDeletesAreVisible (" + arg0 + ")");
        try {
            _result = this._inner.ownDeletesAreVisible (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 ownInsertsAreVisible (
        int arg0)
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".ownInsertsAreVisible (" + arg0 + ")");
        try {
            _result = this._inner.ownInsertsAreVisible (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 ownUpdatesAreVisible (
        int arg0)
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".ownUpdatesAreVisible (" + arg0 + ")");
        try {
            _result = this._inner.ownUpdatesAreVisible (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 storesLowerCaseIdentifiers ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".storesLowerCaseIdentifiers (" + ")");
        try {
            _result = this._inner.storesLowerCaseIdentifiers ();
            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 storesLowerCaseQuotedIdentifiers ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".storesLowerCaseQuotedIdentifiers (" + ")");
        try {
            _result = this._inner.storesLowerCaseQuotedIdentifiers ();
            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 storesMixedCaseIdentifiers ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".storesMixedCaseIdentifiers (" + ")");
        try {
            _result = this._inner.storesMixedCaseIdentifiers ();
            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 storesMixedCaseQuotedIdentifiers ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".storesMixedCaseQuotedIdentifiers (" + ")");
        try {
            _result = this._inner.storesMixedCaseQuotedIdentifiers ();
            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 storesUpperCaseIdentifiers ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".storesUpperCaseIdentifiers (" + ")");
        try {
            _result = this._inner.storesUpperCaseIdentifiers ();
            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 storesUpperCaseQuotedIdentifiers ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".storesUpperCaseQuotedIdentifiers (" + ")");
        try {
            _result = this._inner.storesUpperCaseQuotedIdentifiers ();
            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 supportsANSI92EntryLevelSQL ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsANSI92EntryLevelSQL (" + ")");
        try {
            _result = this._inner.supportsANSI92EntryLevelSQL ();
            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 supportsANSI92FullSQL ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsANSI92FullSQL (" + ")");
        try {
            _result = this._inner.supportsANSI92FullSQL ();
            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 supportsANSI92IntermediateSQL ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsANSI92IntermediateSQL (" + ")");
        try {
            _result = this._inner.supportsANSI92IntermediateSQL ();
            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 supportsAlterTableWithAddColumn ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsAlterTableWithAddColumn (" + ")");
        try {
            _result = this._inner.supportsAlterTableWithAddColumn ();
            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 supportsAlterTableWithDropColumn ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsAlterTableWithDropColumn (" + ")");
        try {
            _result = this._inner.supportsAlterTableWithDropColumn ();
            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 supportsBatchUpdates ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsBatchUpdates (" + ")");
        try {
            _result = this._inner.supportsBatchUpdates ();
            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 supportsCatalogsInDataManipulation ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsCatalogsInDataManipulation (" + ")");
        try {
            _result = this._inner.supportsCatalogsInDataManipulation ();
            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 supportsCatalogsInIndexDefinitions ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsCatalogsInIndexDefinitions (" + ")");
        try {
            _result = this._inner.supportsCatalogsInIndexDefinitions ();
            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 supportsCatalogsInPrivilegeDefinitions ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsCatalogsInPrivilegeDefinitions (" + ")");
        try {
            _result = this._inner.supportsCatalogsInPrivilegeDefinitions ();
            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 supportsCatalogsInProcedureCalls ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsCatalogsInProcedureCalls (" + ")");
        try {
            _result = this._inner.supportsCatalogsInProcedureCalls ();
            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 supportsCatalogsInTableDefinitions ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsCatalogsInTableDefinitions (" + ")");
        try {
            _result = this._inner.supportsCatalogsInTableDefinitions ();
            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 supportsColumnAliasing ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsColumnAliasing (" + ")");
        try {
            _result = this._inner.supportsColumnAliasing ();
            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 supportsConvert (
        int arg0,
        int arg1)
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsConvert (" + arg0 + ", " + arg1 + ")");
        try {
            _result = this._inner.supportsConvert (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 supportsConvert ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsConvert (" + ")");
        try {
            _result = this._inner.supportsConvert ();
            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 supportsCoreSQLGrammar ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsCoreSQLGrammar (" + ")");
        try {
            _result = this._inner.supportsCoreSQLGrammar ();
            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 supportsCorrelatedSubqueries ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsCorrelatedSubqueries (" + ")");
        try {
            _result = this._inner.supportsCorrelatedSubqueries ();
            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 supportsDataDefinitionAndDataManipulationTransactions ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsDataDefinitionAndDataManipulationTransactions (" + ")");
        try {
            _result = this._inner.supportsDataDefinitionAndDataManipulationTransactions ();
            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 supportsDataManipulationTransactionsOnly ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsDataManipulationTransactionsOnly (" + ")");
        try {
            _result = this._inner.supportsDataManipulationTransactionsOnly ();
            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 supportsDifferentTableCorrelationNames ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsDifferentTableCorrelationNames (" + ")");
        try {
            _result = this._inner.supportsDifferentTableCorrelationNames ();
            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 supportsExpressionsInOrderBy ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsExpressionsInOrderBy (" + ")");
        try {
            _result = this._inner.supportsExpressionsInOrderBy ();
            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 supportsExtendedSQLGrammar ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsExtendedSQLGrammar (" + ")");
        try {
            _result = this._inner.supportsExtendedSQLGrammar ();
            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 supportsFullOuterJoins ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsFullOuterJoins (" + ")");
        try {
            _result = this._inner.supportsFullOuterJoins ();
            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 supportsGetGeneratedKeys ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsGetGeneratedKeys (" + ")");
        try {
            _result = this._inner.supportsGetGeneratedKeys ();
            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 supportsGroupBy ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsGroupBy (" + ")");
        try {
            _result = this._inner.supportsGroupBy ();
            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 supportsGroupByBeyondSelect ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsGroupByBeyondSelect (" + ")");
        try {
            _result = this._inner.supportsGroupByBeyondSelect ();
            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 supportsGroupByUnrelated ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsGroupByUnrelated (" + ")");
        try {
            _result = this._inner.supportsGroupByUnrelated ();
            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 supportsIntegrityEnhancementFacility ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsIntegrityEnhancementFacility (" + ")");
        try {
            _result = this._inner.supportsIntegrityEnhancementFacility ();
            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 supportsLikeEscapeClause ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsLikeEscapeClause (" + ")");
        try {
            _result = this._inner.supportsLikeEscapeClause ();
            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 supportsLimitedOuterJoins ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsLimitedOuterJoins (" + ")");
        try {
            _result = this._inner.supportsLimitedOuterJoins ();
            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 supportsMinimumSQLGrammar ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsMinimumSQLGrammar (" + ")");
        try {
            _result = this._inner.supportsMinimumSQLGrammar ();
            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 supportsMixedCaseIdentifiers ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsMixedCaseIdentifiers (" + ")");
        try {
            _result = this._inner.supportsMixedCaseIdentifiers ();
            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 supportsMixedCaseQuotedIdentifiers ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsMixedCaseQuotedIdentifiers (" + ")");
        try {
            _result = this._inner.supportsMixedCaseQuotedIdentifiers ();
            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 supportsMultipleOpenResults ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsMultipleOpenResults (" + ")");
        try {
            _result = this._inner.supportsMultipleOpenResults ();
            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 supportsMultipleResultSets ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsMultipleResultSets (" + ")");
        try {
            _result = this._inner.supportsMultipleResultSets ();
            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 supportsMultipleTransactions ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsMultipleTransactions (" + ")");
        try {
            _result = this._inner.supportsMultipleTransactions ();
            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 supportsNamedParameters ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsNamedParameters (" + ")");
        try {
            _result = this._inner.supportsNamedParameters ();
            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 supportsNonNullableColumns ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsNonNullableColumns (" + ")");
        try {
            _result = this._inner.supportsNonNullableColumns ();
            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 supportsOpenCursorsAcrossCommit ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsOpenCursorsAcrossCommit (" + ")");
        try {
            _result = this._inner.supportsOpenCursorsAcrossCommit ();
            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 supportsOpenCursorsAcrossRollback ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsOpenCursorsAcrossRollback (" + ")");
        try {
            _result = this._inner.supportsOpenCursorsAcrossRollback ();
            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 supportsOpenStatementsAcrossCommit ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsOpenStatementsAcrossCommit (" + ")");
        try {
            _result = this._inner.supportsOpenStatementsAcrossCommit ();
            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 supportsOpenStatementsAcrossRollback ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsOpenStatementsAcrossRollback (" + ")");
        try {
            _result = this._inner.supportsOpenStatementsAcrossRollback ();
            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 supportsOrderByUnrelated ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsOrderByUnrelated (" + ")");
        try {
            _result = this._inner.supportsOrderByUnrelated ();
            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 supportsOuterJoins ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsOuterJoins (" + ")");
        try {
            _result = this._inner.supportsOuterJoins ();
            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 supportsPositionedDelete ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsPositionedDelete (" + ")");
        try {
            _result = this._inner.supportsPositionedDelete ();
            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 supportsPositionedUpdate ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsPositionedUpdate (" + ")");
        try {
            _result = this._inner.supportsPositionedUpdate ();
            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 supportsResultSetConcurrency (
        int arg0,
        int arg1)
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsResultSetConcurrency (" + arg0 + ", " + arg1 + ")");
        try {
            _result = this._inner.supportsResultSetConcurrency (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 supportsResultSetHoldability (
        int arg0)
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsResultSetHoldability (" + arg0 + ")");
        try {
            _result = this._inner.supportsResultSetHoldability (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 supportsResultSetType (
        int arg0)
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsResultSetType (" + arg0 + ")");
        try {
            _result = this._inner.supportsResultSetType (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 supportsSavepoints ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsSavepoints (" + ")");
        try {
            _result = this._inner.supportsSavepoints ();
            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 supportsSchemasInDataManipulation ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsSchemasInDataManipulation (" + ")");
        try {
            _result = this._inner.supportsSchemasInDataManipulation ();
            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 supportsSchemasInIndexDefinitions ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsSchemasInIndexDefinitions (" + ")");
        try {
            _result = this._inner.supportsSchemasInIndexDefinitions ();
            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 supportsSchemasInPrivilegeDefinitions ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsSchemasInPrivilegeDefinitions (" + ")");
        try {
            _result = this._inner.supportsSchemasInPrivilegeDefinitions ();
            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 supportsSchemasInProcedureCalls ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsSchemasInProcedureCalls (" + ")");
        try {
            _result = this._inner.supportsSchemasInProcedureCalls ();
            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 supportsSchemasInTableDefinitions ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsSchemasInTableDefinitions (" + ")");
        try {
            _result = this._inner.supportsSchemasInTableDefinitions ();
            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 supportsSelectForUpdate ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsSelectForUpdate (" + ")");
        try {
            _result = this._inner.supportsSelectForUpdate ();
            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 supportsStatementPooling ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsStatementPooling (" + ")");
        try {
            _result = this._inner.supportsStatementPooling ();
            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 supportsStoredProcedures ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsStoredProcedures (" + ")");
        try {
            _result = this._inner.supportsStoredProcedures ();
            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 supportsSubqueriesInComparisons ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsSubqueriesInComparisons (" + ")");
        try {
            _result = this._inner.supportsSubqueriesInComparisons ();
            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 supportsSubqueriesInExists ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsSubqueriesInExists (" + ")");
        try {
            _result = this._inner.supportsSubqueriesInExists ();
            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 supportsSubqueriesInIns ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsSubqueriesInIns (" + ")");
        try {
            _result = this._inner.supportsSubqueriesInIns ();
            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 supportsSubqueriesInQuantifieds ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsSubqueriesInQuantifieds (" + ")");
        try {
            _result = this._inner.supportsSubqueriesInQuantifieds ();
            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 supportsTableCorrelationNames ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsTableCorrelationNames (" + ")");
        try {
            _result = this._inner.supportsTableCorrelationNames ();
            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 supportsTransactionIsolationLevel (
        int arg0)
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsTransactionIsolationLevel (" + arg0 + ")");
        try {
            _result = this._inner.supportsTransactionIsolationLevel (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 supportsTransactions ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsTransactions (" + ")");
        try {
            _result = this._inner.supportsTransactions ();
            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 supportsUnion ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsUnion (" + ")");
        try {
            _result = this._inner.supportsUnion ();
            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 supportsUnionAll ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".supportsUnionAll (" + ")");
        try {
            _result = this._inner.supportsUnionAll ();
            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 updatesAreDetected (
        int arg0)
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".updatesAreDetected (" + arg0 + ")");
        try {
            _result = this._inner.updatesAreDetected (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 usesLocalFilePerTable ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".usesLocalFilePerTable (" + ")");
        try {
            _result = this._inner.usesLocalFilePerTable ();
            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 usesLocalFiles ()
    throws java.sql.SQLException
    {
        boolean _result;
        Tracer.println (this._inner + ".usesLocalFiles (" + ")");
        try {
            _result = this._inner.usesLocalFiles ();
            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;
    }


}