db-derby-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From davi...@apache.org
Subject svn commit: r371561 [8/11] - in /db/derby/code/trunk/java: client/org/apache/derby/client/ client/org/apache/derby/client/am/ client/org/apache/derby/client/net/ client/org/apache/derby/jdbc/ testing/org/apache/derbyTesting/functionTests/master/DerbyNe...
Date Mon, 23 Jan 2006 15:58:53 GMT
Modified: db/derby/code/trunk/java/client/org/apache/derby/client/am/ResultSet.java
URL: http://svn.apache.org/viewcvs/db/derby/code/trunk/java/client/org/apache/derby/client/am/ResultSet.java?rev=371561&r1=371560&r2=371561&view=diff
==============================================================================
--- db/derby/code/trunk/java/client/org/apache/derby/client/am/ResultSet.java (original)
+++ db/derby/code/trunk/java/client/org/apache/derby/client/am/ResultSet.java Mon Jan 23 07:58:34 2006
@@ -21,6 +21,7 @@
 package org.apache.derby.client.am;
 
 import java.io.IOException;
+import java.sql.SQLException;
 
 public abstract class ResultSet implements java.sql.ResultSet,
         ResultSetCallbackInterface,
@@ -242,16 +243,23 @@
 
     // ---------------------------jdbc 1------------------------------------------
 
-    public final boolean next() throws SqlException {
-        synchronized (connection_) {
-            if (agent_.loggingEnabled()) {
-                agent_.logWriter_.traceEntry(this, "next");
-            }
-            boolean isValidCursorPosition = nextX();
-            if (agent_.loggingEnabled()) {
-                agent_.logWriter_.traceExit(this, "next", isValidCursorPosition);
+    public final boolean next() throws SQLException {
+        try
+        {
+            synchronized (connection_) {
+                if (agent_.loggingEnabled()) {
+                    agent_.logWriter_.traceEntry(this, "next");
+                }
+                boolean isValidCursorPosition = nextX();
+                if (agent_.loggingEnabled()) {
+                    agent_.logWriter_.traceExit(this, "next", isValidCursorPosition);
+                }
+                return isValidCursorPosition;
             }
-            return isValidCursorPosition;
+        }
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
     }
 
@@ -377,12 +385,19 @@
     }
 
 
-    public void close() throws SqlException {
-        synchronized (connection_) {
-            if (agent_.loggingEnabled()) {
-                agent_.logWriter_.traceEntry(this, "close");
+    public void close() throws SQLException {
+        try
+        {
+            synchronized (connection_) {
+                if (agent_.loggingEnabled()) {
+                    agent_.logWriter_.traceEntry(this, "close");
+                }
+                closeX();
             }
-            closeX();
+        }
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
     }
 
@@ -484,645 +499,808 @@
         }
     }
 
-    public boolean wasNull() throws SqlException {
+    public boolean wasNull() throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "wasNull");
+            }
+            checkForClosedResultSet();
 
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "wasNull");
-        }
-        checkForClosedResultSet();
+            if (wasNull_ == ResultSet.WAS_NULL_UNSET) {
+                throw new SqlException(agent_.logWriter_, "Invalid operation: wasNull() called with no data retrieved");
+            }
 
-        if (wasNull_ == ResultSet.WAS_NULL_UNSET) {
-            throw new SqlException(agent_.logWriter_, "Invalid operation: wasNull() called with no data retrieved");
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceExit(this, "wasNull", wasNull_ == ResultSet.WAS_NULL);
+            }
+            return wasNull_ == ResultSet.WAS_NULL;
         }
-
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceExit(this, "wasNull", wasNull_ == ResultSet.WAS_NULL);
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return wasNull_ == ResultSet.WAS_NULL;
     }
 
     //------------------- getters on column index --------------------------------
 
     // Live life on the edge and run unsynchronized
-    public boolean getBoolean(int column) throws SqlException {
-	    
-	    closeCloseFilterInputStream();
-	    
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getBoolean", column);
-        }
-        checkGetterPreconditions(column);
-        boolean result = false;
-        if (wasNonNullSensitiveUpdate(column)) {
-            result = agent_.crossConverters_.setBooleanFromObject(updatedColumns_[column - 1],
-                    resultSetMetaData_.types_[column - 1]);
-        } else {
-            result = isNull(column) ? false : cursor_.getBoolean(column);
+    public boolean getBoolean(int column) throws SQLException {
+        try
+        {
+            closeCloseFilterInputStream();
+
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getBoolean", column);
+            }
+            checkGetterPreconditions(column);
+            boolean result = false;
+            if (wasNonNullSensitiveUpdate(column)) {
+                result = agent_.crossConverters_.setBooleanFromObject(updatedColumns_[column - 1],
+                        resultSetMetaData_.types_[column - 1]);
+            } else {
+                result = isNull(column) ? false : cursor_.getBoolean(column);
+            }
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceExit(this, "getBoolean", result);
+            }
+            setWasNull(column);  // Placed close to the return to minimize risk of thread interference
+            return result;
         }
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceExit(this, "getBoolean", result);
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        setWasNull(column);  // Placed close to the return to minimize risk of thread interference
-        return result;
     }
 
     // Live life on the edge and run unsynchronized
-    public byte getByte(int column) throws SqlException {
-	    
-	    closeCloseFilterInputStream();
-	    
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getByte", column);
-        }
-        checkGetterPreconditions(column);
-        byte result = 0;
-        if (wasNonNullSensitiveUpdate(column)) {
-            result = agent_.crossConverters_.setByteFromObject(updatedColumns_[column - 1],
-                    resultSetMetaData_.types_[column - 1]);
-        } else {
-            result = isNull(column) ? 0 : cursor_.getByte(column);
+    public byte getByte(int column) throws SQLException {
+        try
+        {
+            closeCloseFilterInputStream();
+
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getByte", column);
+            }
+            checkGetterPreconditions(column);
+            byte result = 0;
+            if (wasNonNullSensitiveUpdate(column)) {
+                result = agent_.crossConverters_.setByteFromObject(updatedColumns_[column - 1],
+                        resultSetMetaData_.types_[column - 1]);
+            } else {
+                result = isNull(column) ? 0 : cursor_.getByte(column);
+            }
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceExit(this, "getByte", result);
+            }
+            setWasNull(column);  // Placed close to the return to minimize risk of thread interference
+            return result;
         }
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceExit(this, "getByte", result);
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        setWasNull(column);  // Placed close to the return to minimize risk of thread interference
-        return result;
     }
 
     // Live life on the edge and run unsynchronized
-    public short getShort(int column) throws SqlException {
-	    
-	    closeCloseFilterInputStream();
-	    
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getShort", column);
-        }
-        checkGetterPreconditions(column);
-        short result = 0;
-        if (wasNonNullSensitiveUpdate(column)) {
-            result = ((Short) agent_.crossConverters_.setObject(java.sql.Types.SMALLINT,
-                    updatedColumns_[column - 1])).shortValue();
-        } else {
-            result = isNull(column) ? 0 : cursor_.getShort(column);
+    public short getShort(int column) throws SQLException {
+        try
+        {
+            closeCloseFilterInputStream();
+
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getShort", column);
+            }
+            checkGetterPreconditions(column);
+            short result = 0;
+            if (wasNonNullSensitiveUpdate(column)) {
+                result = ((Short) agent_.crossConverters_.setObject(java.sql.Types.SMALLINT,
+                        updatedColumns_[column - 1])).shortValue();
+            } else {
+                result = isNull(column) ? 0 : cursor_.getShort(column);
+            }
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceExit(this, "getShort", result);
+            }
+            setWasNull(column);  // Placed close to the return to minimize risk of thread interference
+            return result;
         }
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceExit(this, "getShort", result);
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        setWasNull(column);  // Placed close to the return to minimize risk of thread interference
-        return result;
     }
 
     // Live life on the edge and run unsynchronized
-    public int getInt(int column) throws SqlException {
-	    
-	    closeCloseFilterInputStream();
-	    
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getInt", column);
-        }
-        checkGetterPreconditions(column);
-        int result = 0;
-        if (wasNonNullSensitiveUpdate(column)) {
-            result = ((Integer) agent_.crossConverters_.setObject(java.sql.Types.INTEGER,
-                    updatedColumns_[column - 1])).intValue();
-        } else {
-            result = isNull(column) ? 0 : cursor_.getInt(column);
+    public int getInt(int column) throws SQLException {
+        try
+        {
+            closeCloseFilterInputStream();
+
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getInt", column);
+            }
+            checkGetterPreconditions(column);
+            int result = 0;
+            if (wasNonNullSensitiveUpdate(column)) {
+                result = ((Integer) agent_.crossConverters_.setObject(java.sql.Types.INTEGER,
+                        updatedColumns_[column - 1])).intValue();
+            } else {
+                result = isNull(column) ? 0 : cursor_.getInt(column);
+            }
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceExit(this, "getInt", result);
+            }
+            setWasNull(column); // this is placed here close to the return to minimize risk of race condition.
+            return result;
         }
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceExit(this, "getInt", result);
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        setWasNull(column); // this is placed here close to the return to minimize risk of race condition.
-        return result;
     }
 
     // Live life on the edge and run unsynchronized
-    public long getLong(int column) throws SqlException {
-	    
-	    closeCloseFilterInputStream();
-	    
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getLong", column);
-        }
-        checkGetterPreconditions(column);
-        long result = 0;
-        if (wasNonNullSensitiveUpdate(column)) {
-            result = ((Long) agent_.crossConverters_.setObject(java.sql.Types.BIGINT,
-                    updatedColumns_[column - 1])).longValue();
-        } else {
-            result = isNull(column) ? 0 : cursor_.getLong(column);
+    public long getLong(int column) throws SQLException {
+        try
+        {
+            closeCloseFilterInputStream();
+
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getLong", column);
+            }
+            checkGetterPreconditions(column);
+            long result = 0;
+            if (wasNonNullSensitiveUpdate(column)) {
+                result = ((Long) agent_.crossConverters_.setObject(java.sql.Types.BIGINT,
+                        updatedColumns_[column - 1])).longValue();
+            } else {
+                result = isNull(column) ? 0 : cursor_.getLong(column);
+            }
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceExit(this, "getLong", result);
+            }
+            setWasNull(column);  // Placed close to the return to minimize risk of thread interference
+            return result;
         }
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceExit(this, "getLong", result);
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        setWasNull(column);  // Placed close to the return to minimize risk of thread interference
-        return result;
     }
 
     // Live life on the edge and run unsynchronized
-    public float getFloat(int column) throws SqlException {
-	    
-	    closeCloseFilterInputStream();
-	    
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getFloat", column);
-        }
-        checkGetterPreconditions(column);
-        float result = 0;
-        if (wasNonNullSensitiveUpdate(column)) {
-            result = ((Float) agent_.crossConverters_.setObject(java.sql.Types.REAL,
-                    updatedColumns_[column - 1])).floatValue();
-        } else {
-            result = isNull(column) ? 0 : cursor_.getFloat(column);
+    public float getFloat(int column) throws SQLException {
+        try
+        {
+            closeCloseFilterInputStream();
+
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getFloat", column);
+            }
+            checkGetterPreconditions(column);
+            float result = 0;
+            if (wasNonNullSensitiveUpdate(column)) {
+                result = ((Float) agent_.crossConverters_.setObject(java.sql.Types.REAL,
+                        updatedColumns_[column - 1])).floatValue();
+            } else {
+                result = isNull(column) ? 0 : cursor_.getFloat(column);
+            }
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceExit(this, "getFloat", result);
+            }
+            setWasNull(column);  // Placed close to the return to minimize risk of thread interference
+            return result;
         }
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceExit(this, "getFloat", result);
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        setWasNull(column);  // Placed close to the return to minimize risk of thread interference
-        return result;
     }
 
     // Live life on the edge and run unsynchronized
-    public double getDouble(int column) throws SqlException {
-	    
-	    closeCloseFilterInputStream();
-	    
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getDouble", column);
-        }
-        checkGetterPreconditions(column);
-        double result = 0;
-        if (wasNonNullSensitiveUpdate(column)) {
-            result = ((Double) agent_.crossConverters_.setObject(java.sql.Types.DOUBLE,
-                    updatedColumns_[column - 1])).doubleValue();
-        } else {
-            result = isNull(column) ? 0 : cursor_.getDouble(column);
+    public double getDouble(int column) throws SQLException {
+        try
+        {
+            closeCloseFilterInputStream();
+
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getDouble", column);
+            }
+            checkGetterPreconditions(column);
+            double result = 0;
+            if (wasNonNullSensitiveUpdate(column)) {
+                result = ((Double) agent_.crossConverters_.setObject(java.sql.Types.DOUBLE,
+                        updatedColumns_[column - 1])).doubleValue();
+            } else {
+                result = isNull(column) ? 0 : cursor_.getDouble(column);
+            }
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceExit(this, "getDouble", result);
+            }
+            setWasNull(column);  // Placed close to the return to minimize risk of thread interference
+            return result;
         }
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceExit(this, "getDouble", result);
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        setWasNull(column);  // Placed close to the return to minimize risk of thread interference
-        return result;
     }
 
     // Live life on the edge and run unsynchronized
-    public java.math.BigDecimal getBigDecimal(int column, int scale) throws SqlException {
-	    
-	    closeCloseFilterInputStream();
-	    
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceDeprecatedEntry(this, "getBigDecimal", column, scale);
-        }
-        checkGetterPreconditions(column);
-        java.math.BigDecimal result = null;
-        if (wasNonNullSensitiveUpdate(column)) {
-            result =
-                    ((java.math.BigDecimal) agent_.crossConverters_.setObject(java.sql.Types.DECIMAL,
-                            updatedColumns_[column - 1])).setScale(scale, java.math.BigDecimal.ROUND_DOWN);
-        } else {
-            result =
-                    isNull(column) ? null : cursor_.getBigDecimal(column).setScale(scale, java.math.BigDecimal.ROUND_DOWN);
+    public java.math.BigDecimal getBigDecimal(int column, int scale) throws SQLException {
+        try
+        {
+            closeCloseFilterInputStream();
+
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceDeprecatedEntry(this, "getBigDecimal", column, scale);
+            }
+            checkGetterPreconditions(column);
+            java.math.BigDecimal result = null;
+            if (wasNonNullSensitiveUpdate(column)) {
+                result =
+                        ((java.math.BigDecimal) agent_.crossConverters_.setObject(java.sql.Types.DECIMAL,
+                                updatedColumns_[column - 1])).setScale(scale, java.math.BigDecimal.ROUND_DOWN);
+            } else {
+                result =
+                        isNull(column) ? null : cursor_.getBigDecimal(column).setScale(scale, java.math.BigDecimal.ROUND_DOWN);
+            }
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceDeprecatedExit(this, "getBigDecimal", result);
+            }
+            setWasNull(column);  // Placed close to the return to minimize risk of thread interference
+            return result;
         }
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceDeprecatedExit(this, "getBigDecimal", result);
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        setWasNull(column);  // Placed close to the return to minimize risk of thread interference
-        return result;
     }
 
     // Live life on the edge and run unsynchronized
-    public java.math.BigDecimal getBigDecimal(int column) throws SqlException {
+    public java.math.BigDecimal getBigDecimal(int column) throws SQLException {
+        try
+        {
 
-	    closeCloseFilterInputStream();
-	    
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getBigDecimal", column);
-        }
-        checkGetterPreconditions(column);
-        java.math.BigDecimal result = null;
-        if (wasNonNullSensitiveUpdate(column)) {
-            result =
-                    (java.math.BigDecimal) agent_.crossConverters_.setObject(java.sql.Types.DECIMAL,
-                            updatedColumns_[column - 1]);
-        } else {
-            result = isNull(column) ? null : cursor_.getBigDecimal(column);
+            closeCloseFilterInputStream();
+
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getBigDecimal", column);
+            }
+            checkGetterPreconditions(column);
+            java.math.BigDecimal result = null;
+            if (wasNonNullSensitiveUpdate(column)) {
+                result =
+                        (java.math.BigDecimal) agent_.crossConverters_.setObject(java.sql.Types.DECIMAL,
+                                updatedColumns_[column - 1]);
+            } else {
+                result = isNull(column) ? null : cursor_.getBigDecimal(column);
+            }
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceExit(this, "getBigDecimal", result);
+            }
+            setWasNull(column);  // Placed close to the return to minimize risk of thread interference
+            return result;
         }
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceExit(this, "getBigDecimal", result);
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        setWasNull(column);  // Placed close to the return to minimize risk of thread interference
-        return result;
     }
 
     // Live life on the edge and run unsynchronized
-    public java.sql.Date getDate(int column) throws SqlException {
-	    
-	    closeCloseFilterInputStream();
-	    
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getDate", column);
-        }
-        checkGetterPreconditions(column);
-        java.sql.Date result = null;
-        if (wasNonNullSensitiveUpdate(column)) {
-            result = (java.sql.Date) agent_.crossConverters_.setObject(java.sql.Types.DATE, updatedColumns_[column - 1]);
-        } else {
-            result = isNull(column) ? null : cursor_.getDate(column);
+    public java.sql.Date getDate(int column) throws SQLException {
+	    try
+        {
+            closeCloseFilterInputStream();
+
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getDate", column);
+            }
+            checkGetterPreconditions(column);
+            java.sql.Date result = null;
+            if (wasNonNullSensitiveUpdate(column)) {
+                result = (java.sql.Date) agent_.crossConverters_.setObject(java.sql.Types.DATE, updatedColumns_[column - 1]);
+            } else {
+                result = isNull(column) ? null : cursor_.getDate(column);
+            }
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceExit(this, "getDate", result);
+            }
+            setWasNull(column);  // Placed close to the return to minimize risk of thread interference
+            return result;
         }
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceExit(this, "getDate", result);
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        setWasNull(column);  // Placed close to the return to minimize risk of thread interference
-        return result;
     }
 
     // Live life on the edge and run unsynchronized
-    public java.sql.Date getDate(int column, java.util.Calendar calendar) throws SqlException {
-	    
-	    closeCloseFilterInputStream();
-	    
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getDate", column, calendar);
-        }
-        if (calendar == null) {
-            throw new SqlException(agent_.logWriter_, "Invalid parameter: calendar is null");
-        }
-        java.sql.Date date = getDate(column);
-        if (date != null) {
-            java.util.Calendar targetCalendar = java.util.Calendar.getInstance(calendar.getTimeZone());
-            targetCalendar.clear();
-            targetCalendar.setTime(date);
-            java.util.Calendar defaultCalendar = java.util.Calendar.getInstance();
-            defaultCalendar.clear();
-            defaultCalendar.setTime(date);
-            long timeZoneOffset =
-                    targetCalendar.get(java.util.Calendar.ZONE_OFFSET) - defaultCalendar.get(java.util.Calendar.ZONE_OFFSET) +
-                    targetCalendar.get(java.util.Calendar.DST_OFFSET) - defaultCalendar.get(java.util.Calendar.DST_OFFSET);
-            date.setTime(date.getTime() - timeZoneOffset);
-        }
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceExit(this, "getDate", date);
+    public java.sql.Date getDate(int column, java.util.Calendar calendar) throws SQLException {
+        try
+        {
+            closeCloseFilterInputStream();
+
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getDate", column, calendar);
+            }
+            if (calendar == null) {
+                throw new SqlException(agent_.logWriter_, "Invalid parameter: calendar is null");
+            }
+            java.sql.Date date = getDate(column);
+            if (date != null) {
+                java.util.Calendar targetCalendar = java.util.Calendar.getInstance(calendar.getTimeZone());
+                targetCalendar.clear();
+                targetCalendar.setTime(date);
+                java.util.Calendar defaultCalendar = java.util.Calendar.getInstance();
+                defaultCalendar.clear();
+                defaultCalendar.setTime(date);
+                long timeZoneOffset =
+                        targetCalendar.get(java.util.Calendar.ZONE_OFFSET) - defaultCalendar.get(java.util.Calendar.ZONE_OFFSET) +
+                        targetCalendar.get(java.util.Calendar.DST_OFFSET) - defaultCalendar.get(java.util.Calendar.DST_OFFSET);
+                date.setTime(date.getTime() - timeZoneOffset);
+            }
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceExit(this, "getDate", date);
+            }
+            return date;
         }
-        return date;
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
+        }            
     }
 
     // Live life on the edge and run unsynchronized
-    public java.sql.Time getTime(int column) throws SqlException {
-	    
-	    closeCloseFilterInputStream();
-	    
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getTime", column);
-        }
-        checkGetterPreconditions(column);
-        java.sql.Time result = null;
-        if (wasNonNullSensitiveUpdate(column)) {
-            result = (java.sql.Time) agent_.crossConverters_.setObject(java.sql.Types.TIME, updatedColumns_[column - 1]);
-        } else {
-            result = isNull(column) ? null : cursor_.getTime(column);
+    public java.sql.Time getTime(int column) throws SQLException {
+        try
+        {
+            closeCloseFilterInputStream();
+
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getTime", column);
+            }
+            checkGetterPreconditions(column);
+            java.sql.Time result = null;
+            if (wasNonNullSensitiveUpdate(column)) {
+                result = (java.sql.Time) agent_.crossConverters_.setObject(java.sql.Types.TIME, updatedColumns_[column - 1]);
+            } else {
+                result = isNull(column) ? null : cursor_.getTime(column);
+            }
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceExit(this, "getTime", result);
+            }
+            setWasNull(column);  // Placed close to the return to minimize risk of thread interference
+            return result;
         }
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceExit(this, "getTime", result);
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        setWasNull(column);  // Placed close to the return to minimize risk of thread interference
-        return result;
     }
 
     // Live life on the edge and run unsynchronized
-    public java.sql.Time getTime(int column, java.util.Calendar calendar) throws SqlException {
-	    
-	    closeCloseFilterInputStream();
-	    
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getTime", column, calendar);
-        }
-        if (calendar == null) {
-            throw new SqlException(agent_.logWriter_, "Invalid parameter: calendar is null");
-        }
-        java.sql.Time time = getTime(column);
-        if (time != null) {
-            java.util.Calendar targetCalendar = java.util.Calendar.getInstance(calendar.getTimeZone());
-            targetCalendar.clear();
-            targetCalendar.setTime(time);
-            java.util.Calendar defaultCalendar = java.util.Calendar.getInstance();
-            defaultCalendar.clear();
-            defaultCalendar.setTime(time);
-            long timeZoneOffset =
-                    targetCalendar.get(java.util.Calendar.ZONE_OFFSET) - defaultCalendar.get(java.util.Calendar.ZONE_OFFSET) +
-                    targetCalendar.get(java.util.Calendar.DST_OFFSET) - defaultCalendar.get(java.util.Calendar.DST_OFFSET);
-            time.setTime(time.getTime() - timeZoneOffset);
+    public java.sql.Time getTime(int column, java.util.Calendar calendar) throws SQLException {
+        try
+        {
+            closeCloseFilterInputStream();
+
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getTime", column, calendar);
+            }
+            if (calendar == null) {
+                throw new SqlException(agent_.logWriter_, "Invalid parameter: calendar is null");
+            }
+            java.sql.Time time = getTime(column);
+            if (time != null) {
+                java.util.Calendar targetCalendar = java.util.Calendar.getInstance(calendar.getTimeZone());
+                targetCalendar.clear();
+                targetCalendar.setTime(time);
+                java.util.Calendar defaultCalendar = java.util.Calendar.getInstance();
+                defaultCalendar.clear();
+                defaultCalendar.setTime(time);
+                long timeZoneOffset =
+                        targetCalendar.get(java.util.Calendar.ZONE_OFFSET) - defaultCalendar.get(java.util.Calendar.ZONE_OFFSET) +
+                        targetCalendar.get(java.util.Calendar.DST_OFFSET) - defaultCalendar.get(java.util.Calendar.DST_OFFSET);
+                time.setTime(time.getTime() - timeZoneOffset);
+            }
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceExit(this, "getTime", time);
+            }
+            return time;
         }
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceExit(this, "getTime", time);
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return time;
     }
 
     // Live life on the edge and run unsynchronized
-    public java.sql.Timestamp getTimestamp(int column) throws SqlException {
-	    
-	    closeCloseFilterInputStream();
-	    
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getTimestamp", column);
-        }
-        checkGetterPreconditions(column);
-        java.sql.Timestamp result = null;
-        if (wasNonNullSensitiveUpdate(column)) {
-            result = (java.sql.Timestamp) agent_.crossConverters_.setObject(java.sql.Types.TIMESTAMP, updatedColumns_[column - 1]);
-        } else {
-            result = isNull(column) ? null : cursor_.getTimestamp(column);
+    public java.sql.Timestamp getTimestamp(int column) throws SQLException {
+	    try
+        {
+            closeCloseFilterInputStream();
+
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getTimestamp", column);
+            }
+            checkGetterPreconditions(column);
+            java.sql.Timestamp result = null;
+            if (wasNonNullSensitiveUpdate(column)) {
+                result = (java.sql.Timestamp) agent_.crossConverters_.setObject(java.sql.Types.TIMESTAMP, updatedColumns_[column - 1]);
+            } else {
+                result = isNull(column) ? null : cursor_.getTimestamp(column);
+            }
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceExit(this, "getTimestamp", result);
+            }
+            setWasNull(column);  // Placed close to the return to minimize risk of thread interference
+            return result;
         }
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceExit(this, "getTimestamp", result);
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        setWasNull(column);  // Placed close to the return to minimize risk of thread interference
-        return result;
     }
 
     // Live life on the edge and run unsynchronized
-    public java.sql.Timestamp getTimestamp(int column, java.util.Calendar calendar) throws SqlException {
-	    
-	    closeCloseFilterInputStream();
-	    
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getTimestamp", column, calendar);
-        }
-        if (calendar == null) {
-            throw new SqlException(agent_.logWriter_, "Invalid parameter: calendar is null");
-        }
-        java.sql.Timestamp timestamp = getTimestamp(column);
-        if (timestamp != null) {
-            int nano = timestamp.getNanos();
-            java.util.Calendar targetCalendar = java.util.Calendar.getInstance(calendar.getTimeZone());
-            targetCalendar.clear();
-            targetCalendar.setTime(timestamp);
-            java.util.Calendar defaultCalendar = java.util.Calendar.getInstance();
-            defaultCalendar.clear();
-            defaultCalendar.setTime(timestamp);
-            long timeZoneOffset =
-                    targetCalendar.get(java.util.Calendar.ZONE_OFFSET) - defaultCalendar.get(java.util.Calendar.ZONE_OFFSET) +
-                    targetCalendar.get(java.util.Calendar.DST_OFFSET) - defaultCalendar.get(java.util.Calendar.DST_OFFSET);
-            timestamp.setTime(timestamp.getTime() - timeZoneOffset);
-            timestamp.setNanos(nano);
+    public java.sql.Timestamp getTimestamp(int column, java.util.Calendar calendar) throws SQLException {
+        try
+        {
+            closeCloseFilterInputStream();
+
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getTimestamp", column, calendar);
+            }
+            if (calendar == null) {
+                throw new SqlException(agent_.logWriter_, "Invalid parameter: calendar is null");
+            }
+            java.sql.Timestamp timestamp = getTimestamp(column);
+            if (timestamp != null) {
+                int nano = timestamp.getNanos();
+                java.util.Calendar targetCalendar = java.util.Calendar.getInstance(calendar.getTimeZone());
+                targetCalendar.clear();
+                targetCalendar.setTime(timestamp);
+                java.util.Calendar defaultCalendar = java.util.Calendar.getInstance();
+                defaultCalendar.clear();
+                defaultCalendar.setTime(timestamp);
+                long timeZoneOffset =
+                        targetCalendar.get(java.util.Calendar.ZONE_OFFSET) - defaultCalendar.get(java.util.Calendar.ZONE_OFFSET) +
+                        targetCalendar.get(java.util.Calendar.DST_OFFSET) - defaultCalendar.get(java.util.Calendar.DST_OFFSET);
+                timestamp.setTime(timestamp.getTime() - timeZoneOffset);
+                timestamp.setNanos(nano);
+            }
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceExit(this, "getTimestamp", timestamp);
+            }
+            return timestamp;
         }
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceExit(this, "getTimestamp", timestamp);
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return timestamp;
     }
 
     // Live life on the edge and run unsynchronized
-    public String getString(int column) throws SqlException {
-	    
-	    closeCloseFilterInputStream();
-	    
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getString", column);
-        }
-        checkGetterPreconditions(column);
-        String result = null;
-        if (wasNonNullSensitiveUpdate(column)) {
-            result = (String) agent_.crossConverters_.setObject(java.sql.Types.CHAR, updatedColumns_[column - 1]);
-        } else {
-            result = isNull(column) ? null : cursor_.getString(column);
+    public String getString(int column) throws SQLException {
+        try
+        {
+            closeCloseFilterInputStream();
+
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getString", column);
+            }
+            checkGetterPreconditions(column);
+            String result = null;
+            if (wasNonNullSensitiveUpdate(column)) {
+                result = (String) agent_.crossConverters_.setObject(java.sql.Types.CHAR, updatedColumns_[column - 1]);
+            } else {
+                result = isNull(column) ? null : cursor_.getString(column);
+            }
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceExit(this, "getString", result);
+            }
+            setWasNull(column);  // Placed close to the return to minimize risk of thread interference
+            return result;
         }
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceExit(this, "getString", result);
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        setWasNull(column);  // Placed close to the return to minimize risk of thread interference
-        return result;
     }
 
     // Live life on the edge and run unsynchronized
-    public byte[] getBytes(int column) throws SqlException {
-	    
-	    closeCloseFilterInputStream();
-	    
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getBytes", column);
-        }
-        checkGetterPreconditions(column);
-        byte[] result = null;
-        if (wasNonNullSensitiveUpdate(column)) {
-            result = (byte[]) agent_.crossConverters_.setObject(java.sql.Types.BINARY, updatedColumns_[column - 1]);
-        } else {
-            result = isNull(column) ? null : cursor_.getBytes(column);
+    public byte[] getBytes(int column) throws SQLException {
+	    try
+        {
+            closeCloseFilterInputStream();
+
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getBytes", column);
+            }
+            checkGetterPreconditions(column);
+            byte[] result = null;
+            if (wasNonNullSensitiveUpdate(column)) {
+                result = (byte[]) agent_.crossConverters_.setObject(java.sql.Types.BINARY, updatedColumns_[column - 1]);
+            } else {
+                result = isNull(column) ? null : cursor_.getBytes(column);
+            }
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceExit(this, "getBytes", result);
+            }
+            setWasNull(column);  // Placed close to the return to minimize risk of thread interference
+            return result;
         }
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceExit(this, "getBytes", result);
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        setWasNull(column);  // Placed close to the return to minimize risk of thread interference
-        return result;
     }
 
     // Live life on the edge and run unsynchronized
-    public java.io.InputStream getBinaryStream(int column) throws SqlException {
-	    
-	    closeCloseFilterInputStream();
-	    
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getBinaryStream", column);
-        }
-	
-        checkGetterPreconditions(column);
-	useStream(column);
+    public java.io.InputStream getBinaryStream(int column) throws SQLException {
+        try
+        {
+            closeCloseFilterInputStream();
 
-        java.io.InputStream result = null;
-        if (wasNonNullSensitiveUpdate(column)) {
-            result = new java.io.ByteArrayInputStream((byte[]) agent_.crossConverters_.setObject(java.sql.Types.BINARY, updatedColumns_[column - 1]));
-        } else {
-            result = isNull(column) ? null : cursor_.getBinaryStream(column);
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getBinaryStream", column);
+            }
+
+            checkGetterPreconditions(column);
+        useStream(column);
+
+            java.io.InputStream result = null;
+            if (wasNonNullSensitiveUpdate(column)) {
+                result = new java.io.ByteArrayInputStream((byte[]) agent_.crossConverters_.setObject(java.sql.Types.BINARY, updatedColumns_[column - 1]));
+            } else {
+                result = isNull(column) ? null : cursor_.getBinaryStream(column);
+            }
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceExit(this, "getBinaryStream", result);
+            }
+            setWasNull(column);  // Placed close to the return to minimize risk of thread interference
+            return createCloseFilterInputStream(result);
         }
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceExit(this, "getBinaryStream", result);
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        setWasNull(column);  // Placed close to the return to minimize risk of thread interference
-        return createCloseFilterInputStream(result);
     }
 
     // Live life on the edge and run unsynchronized
-    public java.io.InputStream getAsciiStream(int column) throws SqlException {
-	    
-	    closeCloseFilterInputStream();
-	    
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getAsciiStream", column);
-        }
-	
-        checkGetterPreconditions(column);
-	useStream(column);
+    public java.io.InputStream getAsciiStream(int column) throws SQLException {
+        try
+        {
+            closeCloseFilterInputStream();
 
-        java.io.InputStream result = null;
-        if (wasNonNullSensitiveUpdate(column)) {
-		
-		result = new AsciiStream((String) agent_.crossConverters_.setObject(java.sql.Types.CHAR,
-										    updatedColumns_[column - 1]));
-        } else {
-            result = isNull(column) ? null : cursor_.getAsciiStream(column);
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getAsciiStream", column);
+            }
+
+            checkGetterPreconditions(column);
+        useStream(column);
+
+            java.io.InputStream result = null;
+            if (wasNonNullSensitiveUpdate(column)) {
+
+            result = new AsciiStream((String) agent_.crossConverters_.setObject(java.sql.Types.CHAR,
+                                                updatedColumns_[column - 1]));
+            } else {
+                result = isNull(column) ? null : cursor_.getAsciiStream(column);
+            }
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceExit(this, "getAsciiStream", result);
+            }
+            setWasNull(column);  // Placed close to the return to minimize risk of thread interference
+            return createCloseFilterInputStream(result);
         }
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceExit(this, "getAsciiStream", result);
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        setWasNull(column);  // Placed close to the return to minimize risk of thread interference
-        return createCloseFilterInputStream(result);
     }
 
     // Live life on the edge and run unsynchronized
-    public java.io.InputStream getUnicodeStream(int column) throws SqlException {
-	    
-	    closeCloseFilterInputStream();
-	    
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceDeprecatedEntry(this, "getUnicodeStream", column);
-        }
-	
-        checkGetterPreconditions(column);
-	useStream(column);
-	
-        java.io.InputStream result = null;
-        if (wasNonNullSensitiveUpdate(column)) {
-            try {
-                result = new java.io.ByteArrayInputStream
-                        (((String) agent_.crossConverters_.setObject(java.sql.Types.CHAR,
-                                updatedColumns_[column - 1])).getBytes("UTF-8"));
-            } catch (java.io.UnsupportedEncodingException e) {
-                throw new SqlException(agent_.logWriter_, e, e.getMessage());
+    public java.io.InputStream getUnicodeStream(int column) throws SQLException {
+        try
+        {
+            closeCloseFilterInputStream();
+
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceDeprecatedEntry(this, "getUnicodeStream", column);
             }
-        } else {
-            result = isNull(column) ? null : cursor_.getUnicodeStream(column);
+
+            checkGetterPreconditions(column);
+        useStream(column);
+
+            java.io.InputStream result = null;
+            if (wasNonNullSensitiveUpdate(column)) {
+                try {
+                    result = new java.io.ByteArrayInputStream
+                            (((String) agent_.crossConverters_.setObject(java.sql.Types.CHAR,
+                                    updatedColumns_[column - 1])).getBytes("UTF-8"));
+                } catch (java.io.UnsupportedEncodingException e) {
+                    throw new SqlException(agent_.logWriter_, e, e.getMessage());
+                }
+            } else {
+                result = isNull(column) ? null : cursor_.getUnicodeStream(column);
+            }
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceDeprecatedExit(this, "getUnicodeStream", result);
+            }
+            setWasNull(column);  // Placed close to the return to minimize risk of thread interference
+            return createCloseFilterInputStream(result);
         }
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceDeprecatedExit(this, "getUnicodeStream", result);
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        setWasNull(column);  // Placed close to the return to minimize risk of thread interference
-        return createCloseFilterInputStream(result);
     }
 
     // Live life on the edge and run unsynchronized
-    public java.io.Reader getCharacterStream(int column) throws SqlException {
-	    
-	    closeCloseFilterInputStream();
-	    
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getCharacterStream", column);
-        }
-	
-        checkGetterPreconditions(column);
-	useStream(column);
-	
-        java.io.Reader result = null;
-        if (wasNonNullSensitiveUpdate(column)) {
-            result = new java.io.StringReader
-                    ((String) agent_.crossConverters_.setObject(java.sql.Types.CHAR, updatedColumns_[column - 1]));
-        } else {
-            result = isNull(column) ? null : cursor_.getCharacterStream(column);
+    public java.io.Reader getCharacterStream(int column) throws SQLException {
+        try
+        {
+            closeCloseFilterInputStream();
+
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getCharacterStream", column);
+            }
+
+            checkGetterPreconditions(column);
+        useStream(column);
+
+            java.io.Reader result = null;
+            if (wasNonNullSensitiveUpdate(column)) {
+                result = new java.io.StringReader
+                        ((String) agent_.crossConverters_.setObject(java.sql.Types.CHAR, updatedColumns_[column - 1]));
+            } else {
+                result = isNull(column) ? null : cursor_.getCharacterStream(column);
+            }
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceExit(this, "getCharacterStream", result);
+            }
+            setWasNull(column);  // Placed close to the return to minimize risk of thread interference
+            return result;
         }
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceExit(this, "getCharacterStream", result);
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        setWasNull(column);  // Placed close to the return to minimize risk of thread interference
-        return result;
     }
 
     // Live life on the edge and run unsynchronized
-    public java.sql.Blob getBlob(int column) throws SqlException {
-	    
-	    closeCloseFilterInputStream();
-	    
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getBlob", column);
-        }
-        checkGetterPreconditions(column);
-        java.sql.Blob result = null;
-        if (wasNonNullSensitiveUpdate(column)) {
-            result = (java.sql.Blob) agent_.crossConverters_.setObject(java.sql.Types.BLOB,
-                    updatedColumns_[column - 1]);
-        } else {
-            result = isNull(column) ? null : cursor_.getBlob(column);
+    public java.sql.Blob getBlob(int column) throws SQLException {
+        try
+        {
+            closeCloseFilterInputStream();
+
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getBlob", column);
+            }
+            checkGetterPreconditions(column);
+            java.sql.Blob result = null;
+            if (wasNonNullSensitiveUpdate(column)) {
+                result = (java.sql.Blob) agent_.crossConverters_.setObject(java.sql.Types.BLOB,
+                        updatedColumns_[column - 1]);
+            } else {
+                result = isNull(column) ? null : cursor_.getBlob(column);
+            }
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceExit(this, "getBlob", result);
+            }
+            setWasNull(column);  // Placed close to the return to minimize risk of thread interference
+            return result;
         }
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceExit(this, "getBlob", result);
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        setWasNull(column);  // Placed close to the return to minimize risk of thread interference
-        return result;
     }
 
     // Live life on the edge and run unsynchronized
-    public java.sql.Clob getClob(int column) throws SqlException {
-	    
-	    closeCloseFilterInputStream();
-	    
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getClob", column);
-        }
-        checkGetterPreconditions(column);
-        java.sql.Clob result = null;
-        if (wasNonNullSensitiveUpdate(column)) {
-            result = (java.sql.Clob) agent_.crossConverters_.setObject(java.sql.Types.CLOB,
-                    updatedColumns_[column - 1]);
-        } else {
-            result = isNull(column) ? null : cursor_.getClob(column);
+    public java.sql.Clob getClob(int column) throws SQLException {
+        try
+        {
+            closeCloseFilterInputStream();
+
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getClob", column);
+            }
+            checkGetterPreconditions(column);
+            java.sql.Clob result = null;
+            if (wasNonNullSensitiveUpdate(column)) {
+                result = (java.sql.Clob) agent_.crossConverters_.setObject(java.sql.Types.CLOB,
+                        updatedColumns_[column - 1]);
+            } else {
+                result = isNull(column) ? null : cursor_.getClob(column);
+            }
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceExit(this, "getClob", result);
+            }
+            setWasNull(column);  // Placed close to the return to minimize risk of thread interference
+            return result;
         }
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceExit(this, "getClob", result);
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        setWasNull(column);  // Placed close to the return to minimize risk of thread interference
-        return result;
     }
 
     // Live life on the edge and run unsynchronized
-    public java.sql.Ref getRef(int column) throws SqlException {
-	    
-	    closeCloseFilterInputStream();
-	    
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getRef", column);
-        }
-        checkGetterPreconditions(column);
-        java.sql.Ref result = isNull(column) ? null : cursor_.getRef(column);
-        if (true) {
-            throw new SqlException(agent_.logWriter_, "jdbc 2 method not yet implemented");
+    public java.sql.Ref getRef(int column) throws SQLException {
+        try
+        {
+            closeCloseFilterInputStream();
+
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getRef", column);
+            }
+            checkGetterPreconditions(column);
+            java.sql.Ref result = isNull(column) ? null : cursor_.getRef(column);
+            if (true) {
+                throw new SqlException(agent_.logWriter_, "jdbc 2 method not yet implemented");
+            }
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceExit(this, "getRef", result);
+            }
+            setWasNull(column);  // Placed close to the return to minimize risk of thread interference
+            return result;
         }
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceExit(this, "getRef", result);
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        setWasNull(column);  // Placed close to the return to minimize risk of thread interference
-        return result;
     }
 
     // Live life on the edge and run unsynchronized
-    public java.sql.Array getArray(int column) throws SqlException {
-	    
-	    closeCloseFilterInputStream();
-	    
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getArray", column);
-        }
-        checkGetterPreconditions(column);
-        java.sql.Array result = isNull(column) ? null : cursor_.getArray(column);
-        if (true) {
-            throw new SqlException(agent_.logWriter_, "jdbc 2 method not yet implemented");
+    public java.sql.Array getArray(int column) throws SQLException {
+	    try
+        {
+            closeCloseFilterInputStream();
+
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getArray", column);
+            }
+            checkGetterPreconditions(column);
+            java.sql.Array result = isNull(column) ? null : cursor_.getArray(column);
+            if (true) {
+                throw new SqlException(agent_.logWriter_, "jdbc 2 method not yet implemented");
+            }
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceExit(this, "getArray", result);
+            }
+            setWasNull(column);  // Placed close to the return to minimize risk of thread interference
+            return result;
         }
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceExit(this, "getArray", result);
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        setWasNull(column);  // Placed close to the return to minimize risk of thread interference
-        return result;
     }
 
     // Live life on the edge and run unsynchronized
-    public Object getObject(int column) throws SqlException {
-	    
-	    closeCloseFilterInputStream();
-	    
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getObject", column);
+    public Object getObject(int column) throws SQLException {
+        try
+        {
+            closeCloseFilterInputStream();
+
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getObject", column);
+            }
+            Object result = getObjectX(column);
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceExit(this, "getObject", result);
+            }
+            return result;
         }
-        Object result = getObjectX(column);
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceExit(this, "getObject", result);
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return result;
     }
 
     // used by DBMD
@@ -1139,28 +1317,34 @@
     }
 
     // Live life on the edge and run unsynchronized
-    public Object getObject(int column, java.util.Map map) throws SqlException {
-	    
-	    closeCloseFilterInputStream();
-	    
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getObject", column, map);
-        }
-        checkGetterPreconditions(column);
-        Object result = null;
-        if (wasNonNullSensitiveUpdate(column)) {
-            result = updatedColumns_[column - 1];
-        } else {
-            result = isNull(column) ? null : cursor_.getObject(column);
-        }
-        if (true) {
-            throw new SqlException(agent_.logWriter_, "jdbc 2 method not yet implemented");
+    public Object getObject(int column, java.util.Map map) throws SQLException {
+        try
+        {
+            closeCloseFilterInputStream();
+
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getObject", column, map);
+            }
+            checkGetterPreconditions(column);
+            Object result = null;
+            if (wasNonNullSensitiveUpdate(column)) {
+                result = updatedColumns_[column - 1];
+            } else {
+                result = isNull(column) ? null : cursor_.getObject(column);
+            }
+            if (true) {
+                throw new SqlException(agent_.logWriter_, "jdbc 2 method not yet implemented");
+            }
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceExit(this, "getObject", result);
+            }
+            setWasNull(column);  // Placed close to the return to minimize risk of thread interference
+            return result;
         }
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceExit(this, "getObject", result);
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        setWasNull(column);  // Placed close to the return to minimize risk of thread interference
-        return result;
     }
 
     //----------------------------------------------------------------------------
@@ -1205,193 +1389,382 @@
 
     // ------------- Methods for accessing results by column name ----------------
 
-    public final boolean getBoolean(String columnName) throws SqlException {
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getBoolean", columnName);
+    public final boolean getBoolean(String columnName) throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getBoolean", columnName);
+            }
+            return getBoolean(findColumnX(columnName));
+        }
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return getBoolean(findColumnX(columnName));
     }
 
-    public final byte getByte(String columnName) throws SqlException {
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getByte", columnName);
+    public final byte getByte(String columnName) throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getByte", columnName);
+            }
+            return getByte(findColumnX(columnName));
+        }
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return getByte(findColumnX(columnName));
     }
 
-    public final short getShort(String columnName) throws SqlException {
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getShort", columnName);
+    public final short getShort(String columnName) throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getShort", columnName);
+            }
+            return getShort(findColumnX(columnName));
+        }
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return getShort(findColumnX(columnName));
     }
 
-    public final int getInt(String columnName) throws SqlException {
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getInt", columnName);
+    public final int getInt(String columnName) throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getInt", columnName);
+            }
+            return getInt(findColumnX(columnName));
+        }
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return getInt(findColumnX(columnName));
     }
 
-    public final long getLong(String columnName) throws SqlException {
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getLong", columnName);
+    public final long getLong(String columnName) throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getLong", columnName);
+            }
+            return getLong(findColumnX(columnName));
+        }
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return getLong(findColumnX(columnName));
     }
 
-    public final float getFloat(String columnName) throws SqlException {
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getFloat", columnName);
+    public final float getFloat(String columnName) throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getFloat", columnName);
+            }
+            return getFloat(findColumnX(columnName));
+        }
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return getFloat(findColumnX(columnName));
     }
 
-    public final double getDouble(String columnName) throws SqlException {
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getDouble", columnName);
+    public final double getDouble(String columnName) throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getDouble", columnName);
+            }
+            return getDouble(findColumnX(columnName));
+        }
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return getDouble(findColumnX(columnName));
     }
 
-    public final java.math.BigDecimal getBigDecimal(String columnName, int scale) throws SqlException {
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceDeprecatedEntry(this, "getBigDecimal", columnName, scale);
+    public final java.math.BigDecimal getBigDecimal(String columnName, int scale) throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceDeprecatedEntry(this, "getBigDecimal", columnName, scale);
+            }
+            return getBigDecimal(findColumnX(columnName), scale);
+        }
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return getBigDecimal(findColumnX(columnName), scale);
     }
 
-    public final java.math.BigDecimal getBigDecimal(String columnName) throws SqlException {
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getBigDecimal", columnName);
+    public final java.math.BigDecimal getBigDecimal(String columnName) throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getBigDecimal", columnName);
+            }
+            return getBigDecimal(findColumnX(columnName));
+        }
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return getBigDecimal(findColumnX(columnName));
     }
 
-    public final java.sql.Date getDate(String columnName) throws SqlException {
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getDate", columnName);
+    public final java.sql.Date getDate(String columnName) throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getDate", columnName);
+            }
+            return getDate(findColumnX(columnName));
+        }
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return getDate(findColumnX(columnName));
     }
 
-    public final java.sql.Date getDate(String columnName, java.util.Calendar cal) throws SqlException {
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getDate", columnName, cal);
+    public final java.sql.Date getDate(String columnName, java.util.Calendar cal) throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getDate", columnName, cal);
+            }
+            return getDate(findColumnX(columnName), cal);
+        }
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return getDate(findColumnX(columnName), cal);
     }
 
-    public final java.sql.Time getTime(String columnName) throws SqlException {
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getTime", columnName);
+    public final java.sql.Time getTime(String columnName) throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getTime", columnName);
+            }
+            return getTime(findColumnX(columnName));
+        }
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return getTime(findColumnX(columnName));
     }
 
-    public final java.sql.Time getTime(String columnName, java.util.Calendar cal) throws SqlException {
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getTime", columnName, cal);
+    public final java.sql.Time getTime(String columnName, java.util.Calendar cal) throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getTime", columnName, cal);
+            }
+            return getTime(findColumnX(columnName), cal);
+        }
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return getTime(findColumnX(columnName), cal);
     }
 
-    public final java.sql.Timestamp getTimestamp(String columnName) throws SqlException {
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getTimestamp", columnName);
+    public final java.sql.Timestamp getTimestamp(String columnName) throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getTimestamp", columnName);
+            }
+            return getTimestamp(findColumnX(columnName));
+        }
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return getTimestamp(findColumnX(columnName));
     }
 
-    public final java.sql.Timestamp getTimestamp(String columnName, java.util.Calendar cal) throws SqlException {
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getTimestamp", columnName, cal);
+    public final java.sql.Timestamp getTimestamp(String columnName, java.util.Calendar cal) throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getTimestamp", columnName, cal);
+            }
+            return getTimestamp(findColumnX(columnName), cal);
+        }
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return getTimestamp(findColumnX(columnName), cal);
     }
 
-    public final String getString(String columnName) throws SqlException {
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getString", columnName);
+    public final String getString(String columnName) throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getString", columnName);
+            }
+            return getString(findColumnX(columnName));
+        }
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return getString(findColumnX(columnName));
     }
 
-    public final byte[] getBytes(String columnName) throws SqlException {
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getBytes", columnName);
+    public final byte[] getBytes(String columnName) throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getBytes", columnName);
+            }
+            return getBytes(findColumnX(columnName));
+        }
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return getBytes(findColumnX(columnName));
     }
 
-    public final java.io.InputStream getBinaryStream(String columnName) throws SqlException {
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getBinaryStream", columnName);
+    public final java.io.InputStream getBinaryStream(String columnName) throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getBinaryStream", columnName);
+            }
+            return getBinaryStream(findColumnX(columnName));
+        }
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return getBinaryStream(findColumnX(columnName));
     }
 
-    public final java.io.InputStream getAsciiStream(String columnName) throws SqlException {
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getAsciiStream", columnName);
+    public final java.io.InputStream getAsciiStream(String columnName) throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getAsciiStream", columnName);
+            }
+            return getAsciiStream(findColumnX(columnName));
+        }
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return getAsciiStream(findColumnX(columnName));
     }
 
-    public final java.io.InputStream getUnicodeStream(String columnName) throws SqlException {
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceDeprecatedEntry(this, "getUnicodeStream", columnName);
+    public final java.io.InputStream getUnicodeStream(String columnName) throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceDeprecatedEntry(this, "getUnicodeStream", columnName);
+            }
+            return getUnicodeStream(findColumnX(columnName));
+        }
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return getUnicodeStream(findColumnX(columnName));
     }
 
-    public final java.io.Reader getCharacterStream(String columnName) throws SqlException {
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getCharacterStream", columnName);
+    public final java.io.Reader getCharacterStream(String columnName) throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getCharacterStream", columnName);
+            }
+            return getCharacterStream(findColumnX(columnName));
+        }
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return getCharacterStream(findColumnX(columnName));
     }
 
-    public final java.sql.Blob getBlob(String columnName) throws SqlException {
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getBlob", columnName);
+    public final java.sql.Blob getBlob(String columnName) throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getBlob", columnName);
+            }
+            return getBlob(findColumnX(columnName));
+        }
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return getBlob(findColumnX(columnName));
     }
 
-    public final java.sql.Clob getClob(String columnName) throws SqlException {
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getClob", columnName);
+    public final java.sql.Clob getClob(String columnName) throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getClob", columnName);
+            }
+            return getClob(findColumnX(columnName));
+        }
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return getClob(findColumnX(columnName));
     }
 
-    public final java.sql.Array getArray(String columnName) throws SqlException {
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getArray", columnName);
+    public final java.sql.Array getArray(String columnName) throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getArray", columnName);
+            }
+            return getArray(findColumnX(columnName));
+        }
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return getArray(findColumnX(columnName));
     }
 
-    public final java.sql.Ref getRef(String columnName) throws SqlException {
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getRef", columnName);
+    public final java.sql.Ref getRef(String columnName) throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getRef", columnName);
+            }
+            return getRef(findColumnX(columnName));
+        }
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return getRef(findColumnX(columnName));
     }
 
-    public final Object getObject(String columnName) throws SqlException {
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getObject", columnName);
+    public final Object getObject(String columnName) throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getObject", columnName);
+            }
+            return getObject(findColumnX(columnName));
+        }
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return getObject(findColumnX(columnName));
     }
 
-    public final Object getObject(String columnName, java.util.Map map) throws SqlException {
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getObject", columnName, map);
+    public final Object getObject(String columnName, java.util.Map map) throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getObject", columnName, map);
+            }
+            return getObject(findColumnX(columnName), map);
+        }
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return getObject(findColumnX(columnName), map);
     }
 
     // ----------------Advanced features -----------------------------------------
@@ -1403,7 +1776,7 @@
         return warnings_;
     }
 
-    public final void clearWarnings() throws SqlException {
+    public final void clearWarnings() throws SQLException {
         synchronized (connection_) {
             if (agent_.loggingEnabled()) {
                 agent_.logWriter_.traceEntry(this, "clearWarnings");
@@ -1417,38 +1790,52 @@
         warnings_ = null;
     }
 
-    public String getCursorName() throws SqlException {
-        synchronized (connection_) {
-            if (agent_.loggingEnabled()) {
-                agent_.logWriter_.traceEntry(this, "getCursorName");
-            }
-            checkForClosedResultSet();
-            if (generatedSection_ != null) {
-                return "stored procedure generated cursor:" + generatedSection_.getServerCursorName();
-            }
-            if (statement_.cursorName_ == null) {// cursor name is not in the maps yet.
-                statement_.cursorName_ = statement_.section_.getServerCursorName();
-                if (statement_.section_ instanceof Section) {
-                    agent_.sectionManager_.mapCursorNameToQuerySection(statement_.cursorName_,
-                            (Section) statement_.section_);
+    public String getCursorName() throws SQLException {
+        try
+        {
+            synchronized (connection_) {
+                if (agent_.loggingEnabled()) {
+                    agent_.logWriter_.traceEntry(this, "getCursorName");
                 }
+                checkForClosedResultSet();
+                if (generatedSection_ != null) {
+                    return "stored procedure generated cursor:" + generatedSection_.getServerCursorName();
+                }
+                if (statement_.cursorName_ == null) {// cursor name is not in the maps yet.
+                    statement_.cursorName_ = statement_.section_.getServerCursorName();
+                    if (statement_.section_ instanceof Section) {
+                        agent_.sectionManager_.mapCursorNameToQuerySection(statement_.cursorName_,
+                                (Section) statement_.section_);
+                    }
+                }
+                if (agent_.loggingEnabled()) {
+                    agent_.logWriter_.traceExit(this, "getCursorName", statement_.cursorName_);
+                }
+                return statement_.cursorName_;
             }
-            if (agent_.loggingEnabled()) {
-                agent_.logWriter_.traceExit(this, "getCursorName", statement_.cursorName_);
-            }
-            return statement_.cursorName_;
+        }
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
     }
 
-    public java.sql.ResultSetMetaData getMetaData() throws SqlException {
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "getMetaData");
+    public java.sql.ResultSetMetaData getMetaData() throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "getMetaData");
+            }
+            java.sql.ResultSetMetaData resultSetMetaData = getMetaDataX();
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceExit(this, "getMetaData", resultSetMetaData);
+            }
+            return resultSetMetaData;
         }
-        java.sql.ResultSetMetaData resultSetMetaData = getMetaDataX();
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceExit(this, "getMetaData", resultSetMetaData);
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return resultSetMetaData;
     }
 
     // used by DBMD
@@ -1458,16 +1845,23 @@
     }
 
 
-    public final int findColumn(String columnName) throws SqlException {
-        synchronized (connection_) {
-            if (agent_.loggingEnabled()) {
-                agent_.logWriter_.traceEntry(this, "findColumn", columnName);
-            }
-            int column = findColumnX(columnName);
-            if (agent_.loggingEnabled()) {
-                agent_.logWriter_.traceExit(this, "findColumn", column);
+    public final int findColumn(String columnName) throws SQLException {
+        try
+        {
+            synchronized (connection_) {
+                if (agent_.loggingEnabled()) {
+                    agent_.logWriter_.traceEntry(this, "findColumn", columnName);
+                }
+                int column = findColumnX(columnName);
+                if (agent_.loggingEnabled()) {
+                    agent_.logWriter_.traceExit(this, "findColumn", column);
+                }
+                return column;
             }
-            return column;
+        }
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
     }
 
@@ -1479,18 +1873,25 @@
 
     //-------------------------- Traversal/Positioning ---------------------------
 
-    public boolean isBeforeFirst() throws SqlException {
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "isBeforeFirst");
+    public boolean isBeforeFirst() throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "isBeforeFirst");
+            }
+            checkForClosedResultSet();
+            checkThatResultSetTypeIsScrollable();
+            // Returns false if the ResultSet contains no rows.
+            boolean isBeforeFirst = isBeforeFirstX();
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceExit(this, "isBeforeFirst", isBeforeFirst);
+            }
+            return isBeforeFirst;
         }
-        checkForClosedResultSet();
-        checkThatResultSetTypeIsScrollable();
-        // Returns false if the ResultSet contains no rows.
-        boolean isBeforeFirst = isBeforeFirstX();
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceExit(this, "isBeforeFirst", isBeforeFirst);
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return isBeforeFirst;
     }
 
     private boolean isBeforeFirstX() throws SqlException {
@@ -1503,18 +1904,25 @@
         }
     }
 
-    public boolean isAfterLast() throws SqlException {
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "isAfterLast");
+    public boolean isAfterLast() throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "isAfterLast");
+            }
+            checkForClosedResultSet();
+            checkThatResultSetTypeIsScrollable();
+            // Returns false if the ResultSet contains no rows.
+            boolean isAfterLast = isAfterLastX();
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceExit(this, "isAfterLast", isAfterLast);
+            }
+            return isAfterLast;
         }
-        checkForClosedResultSet();
-        checkThatResultSetTypeIsScrollable();
-        // Returns false if the ResultSet contains no rows.
-        boolean isAfterLast = isAfterLastX();
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceExit(this, "isAfterLast", isAfterLast);
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return isAfterLast;
     }
 
     private boolean isAfterLastX() throws SqlException {
@@ -1529,19 +1937,26 @@
         }
     }
 
-    public boolean isFirst() throws SqlException {
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "isFirst");
+    public boolean isFirst() throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "isFirst");
+            }
+            checkForClosedResultSet();
+            checkThatResultSetTypeIsScrollable();
+            // Not necessary to get the rowCount_ since currentRowInRowset_ is initialized to -1,
+            // and it will not be changed if there is no rows in the ResultSet.
+            boolean isFirst = isFirstX();
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceExit(this, "isFirst", isFirst);
+            }
+            return isFirst;
         }
-        checkForClosedResultSet();
-        checkThatResultSetTypeIsScrollable();
-        // Not necessary to get the rowCount_ since currentRowInRowset_ is initialized to -1,
-        // and it will not be changed if there is no rows in the ResultSet.
-        boolean isFirst = isFirstX();
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceExit(this, "isFirst", isFirst);
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return isFirst;
     }
 
     private boolean isFirstX() {
@@ -1551,18 +1966,25 @@
         return (firstRowInRowset_ == 1 && currentRowInRowset_ == 0);
     }
 
-    public boolean isLast() throws SqlException {
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceEntry(this, "isLast");
+    public boolean isLast() throws SQLException {
+        try
+        {
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceEntry(this, "isLast");
+            }
+            checkForClosedResultSet();
+            checkThatResultSetTypeIsScrollable();
+            // Returns false if the ResultSet contains no rows.
+            boolean isLast = isLastX();
+            if (agent_.loggingEnabled()) {
+                agent_.logWriter_.traceExit(this, "isLast", isLast);
+            }
+            return isLast;
         }
-        checkForClosedResultSet();
-        checkThatResultSetTypeIsScrollable();
-        // Returns false if the ResultSet contains no rows.
-        boolean isLast = isLastX();
-        if (agent_.loggingEnabled()) {
-            agent_.logWriter_.traceExit(this, "isLast", isLast);
+        catch ( SqlException se )
+        {
+            throw se.getSQLException();
         }
-        return isLast;
     }
 
     private boolean isLastX() throws SqlException {
@@ -1574,15 +1996,22 @@
         }
     }
 
-    public void beforeFirst() throws SqlException {
-        synchronized (connection_) {
-            if (agent_.loggingEnabled()) {
-                agent_.logWriter_.traceEntry(this, "beforeFirst");
+    public void beforeFirst() throws SQLException {
+        try
+        {
+            synchronized (connection_) {
+                if (agent_.loggingEnabled()) {
+                    agent_.logWriter_.traceEntry(this, "beforeFirst");
+                }
+                checkForClosedResultSet();
+                checkThatResultSetTypeIsScrollable();
+                clearWarningsX();
+                beforeFirstX();
             }
-            checkForClosedResultSet();

[... 1891 lines stripped ...]


Mime
View raw message