[32/44] incubator-trafodion git commit: Refact package name

[db...@apache.org]

http://git-wip-us.apache.org/repos/asf/incubator-trafodion/blob/51a83dc2/core/conn/jdbc_type2/src/main/java/org/apache/trafodion/jdbc/t2/SQLMXJdbcRowSet.java
----------------------------------------------------------------------
diff --git a/core/conn/jdbc_type2/src/main/java/org/apache/trafodion/jdbc/t2/SQLMXJdbcRowSet.java b/core/conn/jdbc_type2/src/main/java/org/apache/trafodion/jdbc/t2/SQLMXJdbcRowSet.java
new file mode 100644
index 0000000..7a72a78
--- /dev/null
+++ b/core/conn/jdbc_type2/src/main/java/org/apache/trafodion/jdbc/t2/SQLMXJdbcRowSet.java
@@ -0,0 +1,5007 @@
+// @@@ START COPYRIGHT @@@
+//
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+//
+// @@@ END COPYRIGHT @@@
+
+/* -*-java-*-
+ * Filename :		SQLMXJdbcRowSet.java
+ * Description :	
+ */
+
+package org.apache.trafodion.jdbc.t2;
+
+import java.io.*;
+import java.math.BigDecimal;
+import java.net.URL;
+
+import java.sql.*;
+
+import java.util.Calendar;
+import java.util.Hashtable;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Vector;
+
+import javax.naming.*;
+import javax.sql.rowset.*;
+import javax.sql.RowSet;
+import javax.sql.RowSetEvent;
+import javax.sql.RowSetMetaData;
+import javax.sql.RowSetListener;
+
+import javax.sql.rowset.serial.SerialArray;
+import javax.sql.rowset.serial.SerialBlob;
+import javax.sql.rowset.serial.SerialClob;
+
+import java.beans.PropertyChangeSupport;
+
+public class SQLMXJdbcRowSet implements JdbcRowSet, Joinable
+{
+	public void commit() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_commit].methodEntry();
+		try
+		{
+			checkValidState();
+			conn_.commit();
+			if(conn_.getHoldability() != ResultSet.HOLD_CURSORS_OVER_COMMIT)
+			{
+				resultSet_ = null;
+			}
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_commit].methodExit();
+		}
+	}
+
+	public boolean getAutoCommit() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getAutoCommit].methodEntry();
+		try
+		{
+			checkValidState();
+		    return conn_.getAutoCommit();
+		}		
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getAutoCommit].methodExit();
+		}
+	}
+
+	public RowSetWarning getRowSetWarnings() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getRowSetWarnings].methodEntry();
+		try
+		{
+			// RowSet warnings are currently not supported
+			return null;
+		}		
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getRowSetWarnings].methodExit();
+		}
+	}
+
+	public boolean getShowDeleted() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getShowDeleted].methodEntry();
+		try
+		{
+			checkValidState();
+			return showDeleted_;
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getShowDeleted].methodExit();
+		}
+	}
+
+	public void setShowDeleted(boolean flag) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setShowDeleted].methodEntry();
+
+		showDeleted_ = flag;
+
+		if (JdbcDebugCfg.entryActive) debug[methodId_setShowDeleted].methodExit();
+	}
+
+	public SQLWarning getWarnings() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getWarnings].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.getWarnings();
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getWarnings].methodExit();
+		}
+	}
+
+	public void rollback() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_rollback_V].methodEntry();
+		try
+		{
+			clearWarnings();
+			conn_.rollback();
+			resultSet_ = null;
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_rollback_V].methodExit();
+		}
+	}
+
+	public void rollback(Savepoint savepoint) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_rollback_L].methodEntry();
+		try
+		{
+			clearWarnings();
+			conn_.rollback(savepoint);
+			resultSet_ = null;
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_rollback_L].methodExit();
+		}
+	}
+
+	public void setAutoCommit(boolean autoCommit) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setAutoCommit].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_setAutoCommit].methodParameters("autoCommit= " + autoCommit);
+		try
+		{
+			checkValidState();
+			conn_.setAutoCommit(autoCommit);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setAutoCommit].methodExit();
+		}
+	}
+
+	public boolean absolute(int row) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_absolute].methodEntry();
+		try
+		{
+			checkValidState();
+			boolean flag = resultSet_.absolute(row);
+			notifyCursorMoved();
+			return flag;
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_absolute].methodExit();
+		}
+	}
+
+	public void addRowSetListener(RowSetListener rslistener)
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_addRowSetListener].methodEntry();
+		listeners_.add(rslistener);
+		if (JdbcDebugCfg.entryActive) debug[methodId_addRowSetListener].methodExit();
+	}
+
+	public void afterLast() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_afterLast].methodEntry();
+		try
+		{
+			checkValidState();
+			resultSet_.afterLast();
+			notifyCursorMoved();
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_afterLast].methodExit();
+		}
+	}
+	
+	public void beforeFirst() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_beforeFirst].methodEntry();
+		try
+		{
+			checkValidState();
+			resultSet_.beforeFirst();
+			notifyCursorMoved();
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_beforeFirst].methodExit();
+		}
+	}
+
+	public void clearParameters() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_clearParameters].methodEntry();
+		parameters_.clear();
+		if (JdbcDebugCfg.entryActive) debug[methodId_clearParameters].methodExit();
+	}
+
+	public void clearWarnings() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_clearWarnings].methodEntry();
+		try
+		{
+			checkValidState();
+			resultSet_.clearWarnings();
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_clearWarnings].methodExit();
+		}
+	}
+
+	public void cancelRowUpdates() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_cancelRowUpdates].methodEntry();
+		try
+		{
+			checkValidState();
+			resultSet_.cancelRowUpdates();
+			notifyRowChanged();
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_cancelRowUpdates].methodExit();
+		}
+	}
+	
+	public void close() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_close].methodEntry();
+		try
+		{
+			if (resultSet_ != null)
+			{
+				resultSet_.close();
+				resultSet_ = null;
+			}
+			if (prepStmt_ != null)
+			{
+				prepStmt_.close();
+				prepStmt_ = null;
+			}
+			if (conn_ != null)
+			{
+				conn_.close();
+				conn_ = null;
+			}
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_close].methodExit();
+		}
+	}
+
+	public void deleteRow() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_deleteRow].methodEntry();
+		try
+		{
+			checkValidState();
+			resultSet_.deleteRow();
+			notifyRowChanged();
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_deleteRow].methodExit();
+		}
+	}
+
+	public void execute() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_execute].methodEntry();
+		try
+		{
+			prepareStmt();
+			setProperties(prepStmt_);
+			decodeParameters(getParameters(), prepStmt_);
+			resultSet_ = prepStmt_.executeQuery();
+			notifyRowSetChanged();
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_execute].methodExit();
+		}
+	}
+
+	public int findColumn(String columnName) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_findColumn].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.findColumn(columnName);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_findColumn].methodExit();
+		}
+	}
+	
+	public boolean first() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_first].methodEntry();
+		try
+		{
+			checkValidState();
+			boolean flag = resultSet_.first();
+			notifyCursorMoved();
+			return flag;
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_first].methodExit();
+		}
+	}
+	
+	public Array getArray(int columnIndex) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getArray_I].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.getArray(columnIndex);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getArray_I].methodExit();
+		}
+	}
+	
+	public Array getArray(String columnName) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getArray_L].methodEntry();
+		try
+		{
+			return resultSet_.getArray(findColumn(columnName));
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getArray_L].methodExit();
+		}
+	}
+	
+	public InputStream getAsciiStream(int columnIndex) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getAsciiStream_I].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.getAsciiStream(columnIndex);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getAsciiStream_I].methodExit();
+		}
+	}
+	
+	public InputStream getAsciiStream(String columnName) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getAsciiStream_L].methodEntry();
+		try
+		{
+			return resultSet_.getAsciiStream(findColumn(columnName));
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getAsciiStream_L].methodExit();
+		}
+	}
+	
+	public BigDecimal getBigDecimal(int columnIndex) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getBigDecimal_I].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.getBigDecimal(columnIndex);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getBigDecimal_I].methodExit();
+		}
+	}
+
+	/**
+	 * @deprecated Method getBigDecimal is deprecated
+	 */
+	@Deprecated public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getBigDecimal_II].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.getBigDecimal(columnIndex, scale);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getBigDecimal_II].methodExit();
+		}
+	}
+  	
+	public BigDecimal getBigDecimal(String columnName) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getBigDecimal_L].methodEntry();
+		try
+		{
+			return resultSet_.getBigDecimal(findColumn(columnName));
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getBigDecimal_L].methodExit();
+		}
+	}
+
+	/**
+	 * @deprecated Method getBigDecimal is deprecated
+	 */
+	@Deprecated public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getBigDecimal_LI].methodEntry();
+		try
+		{
+			return resultSet_.getBigDecimal(findColumn(columnName), scale);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getBigDecimal_LI].methodExit();
+		}
+	}
+	
+	public InputStream getBinaryStream(int columnIndex) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getBinaryStream_I].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.getBinaryStream(columnIndex);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getBinaryStream_I].methodExit();
+		}
+	}
+
+	public InputStream getBinaryStream(String columnName) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getBinaryStream_L].methodEntry();
+		try
+		{
+			return resultSet_.getBinaryStream(findColumn(columnName));
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getBinaryStream_L].methodExit();
+		}
+	}
+
+	public Blob getBlob(int columnIndex) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getBlob_I].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.getBlob(columnIndex);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getBlob_I].methodExit();
+		}
+	}
+
+	public Blob getBlob(String columnName) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getBlob_L].methodEntry();
+		try
+		{
+			return resultSet_.getBlob(findColumn(columnName));
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getBlob_L].methodExit();
+		}
+	}
+		
+	public boolean getBoolean(int columnIndex) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getBoolean_I].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.getBoolean(columnIndex);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getBoolean_I].methodExit();
+		}
+	}
+	
+	public boolean getBoolean(String columnName) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getBoolean_L].methodEntry();
+		try
+		{
+			return resultSet_.getBoolean(findColumn(columnName));
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getBoolean_L].methodExit();
+		}
+	}
+	
+	public byte getByte(int columnIndex) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getByte_I].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.getByte(columnIndex);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getByte_I].methodExit();
+		}
+	}
+  		
+	public byte getByte(String columnName) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getByte_L].methodEntry();
+		try
+		{
+			return resultSet_.getByte(findColumn(columnName));
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getByte_L].methodExit();
+		}
+	}
+	
+	public byte[] getBytes(int columnIndex) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getBytes_I].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.getBytes(columnIndex);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getBytes_I].methodExit();
+		}
+	}
+	
+	public byte[] getBytes(String columnName) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getBytes_L].methodEntry();
+		try
+		{
+			return resultSet_.getBytes(findColumn(columnName));
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getBytes_L].methodExit();
+		}
+	}
+	
+	public Reader getCharacterStream(int columnIndex) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getCharacterStream_I].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.getCharacterStream(columnIndex);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getCharacterStream_I].methodExit();
+		}
+	}
+	
+	public Reader getCharacterStream(String columnName) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getCharacterStream_L].methodEntry();
+		try
+		{
+			return resultSet_.getCharacterStream(findColumn(columnName));
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getCharacterStream_L].methodExit();
+		}
+	}
+
+	public Clob getClob(int columnIndex) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getClob_I].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.getClob(columnIndex);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getClob_I].methodExit();
+		}
+	}
+	
+	public Clob getClob(String columnName) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getClob_L].methodEntry();
+		try
+		{
+			return resultSet_.getClob(findColumn(columnName));
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getClob_L].methodExit();
+		}
+	}
+
+	public String getCommand()
+	{
+		if (JdbcDebugCfg.entryActive)
+			debug[methodId_getCommand].methodEntry();
+		if (JdbcDebugCfg.traceActive)
+			debug[methodId_getCommand].methodParameters("cmd = " + command_);
+		try
+		{
+			return command_;
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getCommand].methodExit();
+		}
+	}
+
+	public int getConcurrency() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getConcurrency].methodEntry();
+		try
+		{     
+			/*if(resultSet_ != null)
+			concurrency_ = resultSet_.getConcurrency();*/
+			return concurrency_;
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getConcurrency].methodExit();
+		}
+	}
+		  
+	public String getCursorName() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getCursorName].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.getCursorName();
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getCursorName].methodExit();
+		}
+	}
+
+	//Note: This is not in JdbcRowSet spec. Added for additional functionality
+	public DatabaseMetaData getDatabaseMetaData() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getDatabaseMetaData].methodEntry();
+		try
+		{
+			if(conn_ == null)
+			{
+				Connection connection = connect();
+				return connection.getMetaData();
+			}
+			else
+				return conn_.getMetaData();
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getDatabaseMetaData].methodExit();
+		}
+	}
+
+	//Note: This is not in JdbcRowSet spec. Added for additional functionality
+	public ParameterMetaData getParameterMetaData() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getParameterMetaData].methodEntry();
+		try
+		{
+			prepareStmt();
+			return prepStmt_.getParameterMetaData();
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getParameterMetaData].methodExit();
+		}
+	}
+
+	public String getDataSourceName()
+	{
+		if (JdbcDebugCfg.entryActive)
+			debug[methodId_getDataSourceName].methodEntry();
+		if (JdbcDebugCfg.traceActive)
+			debug[methodId_getDataSourceName].methodParameters("dataSourceName = " + dataSourceName_);
+		try
+		{
+			return dataSourceName_;
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getDataSourceName].methodExit();
+		}
+
+	}
+
+	public Date getDate(int columnIndex) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getDate_I].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.getDate(columnIndex);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getDate_I].methodExit();
+		}
+	}
+		  
+	public Date getDate(int columnIndex, Calendar cal) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getDate_IL].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.getDate(columnIndex, cal);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getDate_IL].methodExit();
+		}
+	}
+
+	public Date getDate(String columnName) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getDate_L].methodEntry();
+		try
+		{
+			return resultSet_.getDate(findColumn(columnName));
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getDate_L].methodExit();
+		}
+	}
+
+	public Date getDate(String columnName, Calendar cal) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getDate_SL].methodEntry();
+		try
+		{
+			return resultSet_.getDate(findColumn(columnName), cal);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getDate_SL].methodExit();
+		}
+	}
+
+	public double getDouble(int columnIndex) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getDouble_I].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.getDouble(columnIndex);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getDouble_I].methodExit();
+		}
+	}
+		
+	public double getDouble(String columnName) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getDouble_L].methodEntry();
+		try
+		{
+			return resultSet_.getDouble(findColumn(columnName));
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getDouble_L].methodExit();
+		}
+	}
+
+	public boolean getEscapeProcessing() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getEscapeProcessing].methodEntry();
+		try
+		{
+			return escapeProcessing_;
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getEscapeProcessing].methodExit();
+		}
+	}
+ 	
+	public int getFetchDirection() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getFetchDirection].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.getFetchDirection();
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getFetchDirection].methodExit();
+		}
+	}
+
+	public int getFetchSize() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getFetchSize].methodEntry();
+		int fetchsize = 0;
+		try
+		{
+			fetchSize_ = resultSet_.getFetchSize();
+			return fetchSize_;
+		}
+		catch(NullPointerException nullpointerexception)
+		{
+			fetchSize_ = fetchsize;
+			return fetchSize_;
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getFetchSize].methodExit();
+		}
+	}
+  
+	public float getFloat(int columnIndex) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getFloat_I].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.getFloat(columnIndex);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getFloat_I].methodExit();
+		}
+	}
+  	 
+	public float getFloat(String columnName) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getFloat_L].methodEntry();
+		try
+		{
+			return resultSet_.getFloat(findColumn(columnName));
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getFloat_L].methodExit();
+		}
+	}
+  
+	public int getInt(int columnIndex) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getInt_I].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_getInt_I].methodParameters(
+										  "columnIndex = " + columnIndex);
+		try
+		{
+			checkValidState();
+			return resultSet_.getInt(columnIndex);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getInt_I].methodExit();
+		}
+	}
+  	 
+	public int getInt(String columnName) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getInt_L].methodEntry();
+		try
+		{
+			return resultSet_.getInt(findColumn(columnName));
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getInt_L].methodExit();
+		}
+	}
+  
+	public long getLong(int columnIndex) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getLong_I].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.getLong(columnIndex);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getLong_I].methodExit();
+		}
+	}
+  	 
+	public long getLong(String columnName) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getLong_L].methodEntry();
+		try
+		{
+			return resultSet_.getLong(findColumn(columnName));
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getLong_L].methodExit();
+		}
+	}
+
+	public int getMaxFieldSize() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getMaxFieldSize].methodEntry();
+		try
+		{
+			return maxFieldSize_;
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getMaxFieldSize].methodExit();
+		}
+	}
+
+	public int getMaxRows() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getMaxRows].methodEntry();
+		try
+		{
+			return maxRows_;
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getMaxRows].methodExit();
+		}
+	}
+
+	public ResultSetMetaData getMetaData() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getMetaData].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.getMetaData();
+		}
+		catch(SQLException sqlexception)
+		{
+			prepareStmt();
+			return prepStmt_.getMetaData();
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getMetaData].methodExit();
+		}
+	}
+  
+	public Object getObject(int columnIndex) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getObject_I].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.getObject(columnIndex);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getObject_I].methodExit();
+		}
+	}
+  
+	public Object getObject(int columnIndex, Map<String,Class<?>> map) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getObject_IL].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.getObject(columnIndex, map);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getObject_IL].methodExit();
+		}
+	}
+		
+	public Object getObject(String columnName) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getObject_L].methodEntry();
+		try
+		{
+			return resultSet_.getObject(findColumn(columnName));
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getObject_L].methodExit();
+		}
+	}
+
+	public Object getObject(String columnName, Map<String,Class<?>> map) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getObject_LL].methodEntry();
+		try
+		{
+			return resultSet_.getObject(findColumn(columnName), map);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getObject_LL].methodExit();
+		}
+	}
+  	
+	public String getPassword()
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getPassword].methodEntry();
+		try
+		{
+			return password_;
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getPassword].methodExit();
+		}
+	}
+
+	public int getQueryTimeout() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getQueryTimeout].methodEntry();
+		try
+		{
+			return queryTimeout_;
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getQueryTimeout].methodExit();
+		}
+	}
+
+	public Ref getRef(int columnIndex) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getRef_I].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.getRef(columnIndex);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getRef_I].methodExit();
+		}
+	}
+		
+	public Ref getRef(String columnName) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getRef_L].methodEntry();
+		try
+		{
+			return resultSet_.getRef(findColumn(columnName));
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getRef_L].methodExit();
+		}
+	}
+	
+	public int getRow() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getRow].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.getRow();
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getRow].methodExit();
+		}
+	}
+	  
+	public short getShort(int columnIndex) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getShort_I].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.getShort(columnIndex);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getShort_I].methodExit();
+		}
+	}
+  	  
+	public short getShort(String columnName) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getShort_L].methodEntry();
+		try
+		{
+			return resultSet_.getShort(findColumn(columnName));
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getShort_L].methodExit();
+		}
+	}
+	  
+	public Statement getStatement() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getStatement].methodEntry();
+		try
+		{
+			if(resultSet_ != null)
+				return resultSet_.getStatement();
+			else
+				return null;
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getStatement].methodExit();
+		}
+	}
+		
+	public String getString(int columnIndex) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getString_I].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_getString_I].methodParameters(
+										  "columnIndex = " + columnIndex);
+		try
+		{
+			checkValidState();
+			return resultSet_.getString(columnIndex);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getString_I].methodExit();
+		}
+	}
+
+	public String getString(String columnName) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getString_L].methodEntry();
+		try
+		{
+			return resultSet_.getString(findColumn(columnName));
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getString_L].methodExit();
+		}
+	}
+
+	public Time getTime(int columnIndex) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getTime_I].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.getTime(columnIndex);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getTime_I].methodExit();
+		}
+	}
+
+	public Time getTime(int columnIndex, Calendar cal) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getTime_IL].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.getTime(columnIndex, cal);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getTime_IL].methodExit();
+		}
+	}
+
+	public Time getTime(String columnName) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getTime_L].methodEntry();
+		try
+		{
+			return resultSet_.getTime(findColumn(columnName));
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getTime_L].methodExit();
+		}
+	}
+
+	public Time getTime(String columnName, Calendar cal) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getTime_LL].methodEntry();
+		try
+		{
+			return resultSet_.getTime(findColumn(columnName), cal);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getTime_LL].methodExit();
+		}
+	}
+
+	public Timestamp getTimestamp(int columnIndex) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getTimestamp_I].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.getTimestamp(columnIndex);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getTimestamp_I].methodExit();
+		}
+	}
+	
+	public Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getTimestamp_IL].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.getTimestamp(columnIndex, cal);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getTimestamp_IL].methodExit();
+		}
+	}
+
+	public Timestamp getTimestamp(String columnName) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getTimestamp_L].methodEntry();
+		try
+		{
+			return resultSet_.getTimestamp(findColumn(columnName));
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getTimestamp_L].methodExit();
+		}
+	}
+
+	public Timestamp getTimestamp(String columnName, Calendar cal) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getTimestamp_LL].methodEntry();
+		try
+		{
+			return resultSet_.getTimestamp(findColumn(columnName), cal);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getTimestamp_LL].methodExit();
+		}
+	}
+
+	public int getTransactionIsolation()
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getTransactionIsolation].methodEntry();
+		try
+		{
+			return isolation_;
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getTransactionIsolation].methodExit();
+		}
+	}
+
+	public int getType() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getType].methodEntry();
+		try
+		{
+			checkValidState();
+			//rowSetType_ = resultSet_.getType();
+			return rowSetType_;
+		}
+		catch(SQLException sqle)
+		{
+			return rowSetType_;
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getType].methodExit();
+		}
+	}
+
+	public Map<String,Class<?>> getTypeMap() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getTypeMap].methodEntry();
+		try
+		{
+			return map_;
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getTypeMap].methodExit();
+		}
+	}
+
+	/**
+	 * @deprecated Method getUnicodeStream is deprecated
+	 */
+	@Deprecated public InputStream getUnicodeStream(int columnIndex) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getUnicodeStream_I].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.getUnicodeStream(columnIndex);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getUnicodeStream_I].methodExit();
+		}
+	}
+
+	/**
+	 * @deprecated Method getUnicodeStream is deprecated
+	 */
+	@Deprecated public InputStream getUnicodeStream(String columnName) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getUnicodeStream_L].methodEntry();
+		try
+		{
+			return resultSet_.getUnicodeStream(findColumn(columnName));
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getUnicodeStream_L].methodExit();
+		}
+	}
+
+	public String getUrl() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getUrl].methodEntry();
+		try
+		{
+			return URL_;
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getUrl].methodExit();
+		}
+	}
+
+	public URL getURL(int columnIndex) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getURL_I].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.getURL(columnIndex);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getURL_I].methodExit();
+		}
+	}
+
+	public URL getURL(String  columnName) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getURL_L].methodEntry();
+		try
+		{
+			return resultSet_.getURL(findColumn(columnName));
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getURL_L].methodExit();
+		}
+	}
+
+	public String getUsername()
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getUsername].methodEntry();
+		try
+		{
+			return username_;
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getUsername].methodExit();
+		}
+	}
+
+	public void insertRow() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_insertRow].methodEntry();
+		try
+		{
+			checkValidState();
+			resultSet_.insertRow();
+			notifyRowChanged();
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_insertRow].methodExit();
+		}
+	}
+	  
+	public boolean isAfterLast() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_isAfterLast].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.isAfterLast();
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_isAfterLast].methodExit();
+		}
+	}
+
+	public boolean isBeforeFirst() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_isBeforeFirst].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.isBeforeFirst();
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_isBeforeFirst].methodExit();
+		}
+	}
+
+	public boolean isFirst() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_isFirst].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.isFirst();
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_isFirst].methodExit();
+		}
+	}
+
+	public boolean isLast() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_isLast].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.isLast();
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_isLast].methodExit();
+		}
+	}
+
+	public boolean isReadOnly()
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_isReadOnly].methodEntry();
+		try
+		{
+			return readOnly_;
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_isReadOnly].methodExit();
+		}
+	}
+
+	public boolean last() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_last].methodEntry();
+		try
+		{
+			checkValidState();
+			boolean flag = resultSet_.last();
+			notifyCursorMoved();
+			return flag;
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_last].methodExit();
+		}
+	}
+
+	public void moveToCurrentRow() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_moveToCurrentRow].methodEntry();
+		try
+		{
+			checkValidState();
+			resultSet_.moveToCurrentRow();
+			notifyCursorMoved();
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_moveToCurrentRow].methodExit();
+		}
+	}
+	  
+	public void moveToInsertRow() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_moveToInsertRow].methodEntry();
+		try
+		{
+			checkValidState();
+			resultSet_.moveToInsertRow();
+			notifyCursorMoved();
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_moveToInsertRow].methodExit();
+		}
+	}
+	  
+	public boolean next() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_next].methodEntry();
+		try
+		{
+			checkValidState();
+			boolean flag = resultSet_.next();
+			notifyCursorMoved();
+			return flag;
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_next].methodExit();
+		}
+	}
+
+	public boolean previous() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_previous].methodEntry();
+		try
+		{
+			checkValidState();
+			boolean flag = resultSet_.previous();
+			notifyCursorMoved();
+			return flag;
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_previous].methodExit();
+		}
+	}
+
+	public void refreshRow() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_refreshRow].methodEntry();
+		try
+		{
+			checkValidState();
+			resultSet_.refreshRow();
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_refreshRow].methodExit();
+		}
+	}
+
+	public boolean relative(int row) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_relative].methodEntry();
+		try
+		{
+			checkValidState();
+			boolean flag = resultSet_.relative(row);
+			notifyCursorMoved();
+			return flag;
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_relative].methodExit();
+		}
+	}
+
+	public void removeRowSetListener(RowSetListener rowsetlistener)
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_removeRowSetListener].methodEntry();
+		try
+		{
+			listeners_.remove(rowsetlistener);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_removeRowSetListener].methodExit();
+		}
+	}
+	
+	public boolean rowDeleted() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_rowDeleted].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.rowDeleted();
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_rowDeleted].methodExit();
+		}
+	}
+
+	public boolean rowInserted() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_rowInserted].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.rowInserted();
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_rowInserted].methodExit();
+		}
+	}
+
+	public boolean rowUpdated() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_rowUpdated].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.rowUpdated();
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_rowUpdated].methodExit();
+		}
+	}
+
+	public void setFetchDirection(int direction) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setFetchDirection].methodEntry();
+		try
+		{
+			checkValidState();
+			resultSet_.setFetchDirection(direction);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setFetchDirection].methodExit();
+		}
+	}
+
+	public void setFetchSize(int rows) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setFetchSize].methodEntry();
+		try
+		{
+			checkValidState();
+			resultSet_.setFetchSize(rows);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setFetchSize].methodExit();
+		}
+	}
+
+	public void setArray(int parameterIndex, Array x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setArray].methodEntry();
+		try
+		{
+			validateSetInvocation(parameterIndex);
+			parameters_.put(parameterIndex - 1, new SerialArray(x));
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setArray].methodExit();
+		}
+	}
+
+	public void setAsciiStream(int parameterIndex, InputStream x, int length) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setAsciiStream].methodEntry();
+		try
+		{
+			validateSetInvocation(parameterIndex);
+			Object paramObj[] = new Object[3];
+			paramObj[0] = x;
+			paramObj[1] = length;
+			paramObj[2] = 2;
+			parameters_.put(parameterIndex - 1, paramObj);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setAsciiStream].methodExit();
+		}
+	}
+
+	public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setBigDecimal].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_setBigDecimal].methodParameters(
+										  Integer.toString(parameterIndex)+",?");
+		try
+		{
+			validateSetInvocation(parameterIndex);
+			parameters_.put(parameterIndex - 1, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setBigDecimal].methodExit();
+		}
+	}
+
+	public void setBinaryStream(int parameterIndex, InputStream x, int length) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setBinaryStream].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_setBinaryStream].methodParameters(
+										  Integer.toString(parameterIndex)+",?");
+		try
+		{
+			validateSetInvocation(parameterIndex);
+			Object paramObj[] = new Object[2];
+			paramObj[0] = x;
+			paramObj[1] = length;
+			parameters_.put(parameterIndex - 1, paramObj);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setBinaryStream].methodExit();
+		}
+	}
+
+	public void setBlob(int parameterIndex, Blob x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setBlob].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_setBlob].methodParameters(
+										  Integer.toString(parameterIndex)+",?");
+		try
+		{
+			validateSetInvocation(parameterIndex);
+			parameters_.put(parameterIndex - 1, new SerialBlob(x));
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setBlob].methodExit();
+		}
+	}
+
+	public void setBoolean(int parameterIndex, boolean x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setBoolean].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_setBoolean].methodParameters(
+										  Integer.toString(parameterIndex)+","+Boolean.toString(x));
+		try
+		{
+			validateSetInvocation(parameterIndex);
+			parameters_.put(parameterIndex - 1, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setBoolean].methodExit();
+		}
+	}
+
+	public void setByte(int parameterIndex, byte x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setByte].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_setByte].methodParameters(
+										  Integer.toString(parameterIndex)+","+Byte.toString(x));
+		try
+		{
+			validateSetInvocation(parameterIndex);
+			parameters_.put(parameterIndex - 1, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setByte].methodExit();
+		}
+	}
+
+	public void setBytes(int parameterIndex, byte[] x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setBytes].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_setBytes].methodParameters(
+										  Integer.toString(parameterIndex)+",byte[]");
+		try
+		{
+			validateSetInvocation(parameterIndex);
+			parameters_.put(parameterIndex - 1, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setBytes].methodExit();
+		}
+	}
+
+	public void setCharacterStream(int parameterIndex, Reader reader, int length) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setCharacterStream].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_setCharacterStream].methodParameters(
+										  Integer.toString(parameterIndex)+",?,"+Integer.toString(length));
+		try
+		{
+			validateSetInvocation(parameterIndex);
+			Object paramObj[] = new Object[2];
+			paramObj[0] = reader;
+			paramObj[1] = length;
+			parameters_.put(parameterIndex - 1, paramObj);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setCharacterStream].methodExit();
+		}
+	}
+
+	public void setClob(int parameterIndex, Clob x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setClob].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_setClob].methodParameters(
+										  Integer.toString(parameterIndex)+",?");
+		try
+		{
+			validateSetInvocation(parameterIndex);
+			parameters_.put(parameterIndex - 1, new SerialClob(x));
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setClob].methodExit();
+		}
+	}
+
+	public void setCommand(String cmd) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setCommand].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_setCommand].traceOut(
+										  JdbcDebug.debugLevelEntry,
+										  "cmd = " + cmd);
+		try
+		{
+			String cmd_string = getCommand();
+
+			if(cmd_string != null)
+			{
+				// Only update if the cmd has changed
+				if(!cmd_string.equals(cmd))
+				{
+					// Save off new command and null existing prepStmt_ and ResultSet_
+					command_ = cmd;
+					prepStmt_ = null;
+					resultSet_ = null;
+					clearParameters();
+					propertyChangeSupport_.firePropertyChange("command", cmd_string, cmd);
+				}
+			} 
+			else
+			{
+				command_ = cmd;
+				propertyChangeSupport_.firePropertyChange("command", null, cmd);
+			}
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setCommand].methodExit();
+		}
+	}
+
+	public void setConcurrency(int concurrency) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setConcurrency].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_setConcurrency].methodParameters("concurrency = " + concurrency);
+		try
+		{
+			if (concurrency != ResultSet.CONCUR_READ_ONLY && concurrency != ResultSet.CONCUR_UPDATABLE)
+				throw Messages.createSQLException(locale_, "invalid_resultset_concurrency", null);
+				if((concurrency_ != concurrency) && (prepStmt_ == null)){
+				int current_rs_concurrency = concurrency_;
+				concurrency_ = concurrency;
+				propertyChangeSupport_.firePropertyChange("concurrency", current_rs_concurrency, concurrency);
+			}
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setConcurrency].methodExit();
+		}
+	}
+
+	public void setDataSourceName(String dsname)
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setDataSourceName].methodEntry();
+		try
+		{
+			if(getDataSourceName() != null)
+			{
+				// Check if a new datasource name is defined
+				if(!getDataSourceName().equals(dsname))
+				{
+					String s1 = getDataSourceName();
+					dataSourceName_ = dsname;
+					conn_ = null;
+					prepStmt_ = null;
+					resultSet_ = null;
+					propertyChangeSupport_.firePropertyChange("dataSourceName", s1, dsname);
+				}
+			} 
+			else
+			{
+				dataSourceName_ = dsname;
+				propertyChangeSupport_.firePropertyChange("dataSourceName", null, dsname);
+			}
+			// Set URL_ to null such that connections
+			// are established using dataSourceName_ 
+			URL_ = null;
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setDataSourceName].methodExit();
+		}
+	}
+
+	public void setDate(int parameterIndex, Date date) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setDate_IL].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_setDate_IL].methodParameters(
+										  Integer.toString(parameterIndex)+",?");
+		try
+		{
+			validateSetInvocation(parameterIndex);
+			parameters_.put(parameterIndex - 1, date);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setDate_IL].methodExit();
+		}
+	}
+
+	public void setDate(int parameterIndex, Date date, Calendar cal) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setDate_ILL].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_setDate_ILL].methodParameters(
+										  Integer.toString(parameterIndex)+",?,?");
+		try
+		{
+			validateSetInvocation(parameterIndex);
+			Object paramObj[] = new Object[2];
+			paramObj[0] = date;
+			paramObj[1] = cal;
+			parameters_.put(parameterIndex - 1, paramObj);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setDate_ILL].methodExit();
+		}
+	}
+
+	public void setDouble(int parameterIndex, double x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setDouble].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_setDouble].methodParameters(
+										  Integer.toString(parameterIndex)+","+Double.toString(x));
+		try
+		{
+			validateSetInvocation(parameterIndex);
+			parameters_.put(parameterIndex - 1, new Double(x));
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setDouble].methodExit();
+		}
+	}
+
+	public void setEscapeProcessing(boolean enable) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setEscapeProcessing].methodEntry();
+		try
+		{
+			escapeProcessing_ = enable;
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setEscapeProcessing].methodExit();
+		}
+	}
+
+	public void setFloat(int parameterIndex, float x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setFloat].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_setFloat].methodParameters(
+										  Integer.toString(parameterIndex)+","+Float.toString(x));
+		try
+		{
+			validateSetInvocation(parameterIndex);
+			parameters_.put(parameterIndex - 1, new Float(x));
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setFloat].methodExit();
+		}
+	}
+
+	public void setInt(int parameterIndex, int x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setInt].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_setInt].methodParameters(
+										  Integer.toString(parameterIndex)+","+Integer.toString(x));
+		try
+		{
+			validateSetInvocation(parameterIndex);
+			parameters_.put(parameterIndex - 1, new Integer(x));
+		}		
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setInt].methodExit();
+		}
+	}
+
+	public void setLong(int parameterIndex, long x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setLong].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_setLong].methodParameters(
+										  Integer.toString(parameterIndex)+","+Long.toString(x));
+		try
+		{
+			validateSetInvocation(parameterIndex);
+			parameters_.put(parameterIndex - 1, new Long(x));
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setLong].methodExit();
+		}
+	}
+
+	public void setMaxFieldSize(int max) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setMaxFieldSize].methodEntry();
+		try
+		{
+			if (max < 0)
+				throw Messages.createSQLException(locale_, "invalid_maxFieldSize_value", null);
+			int currentMaxFieldSize;
+			currentMaxFieldSize = maxFieldSize_;
+			if(currentMaxFieldSize != max)
+			{
+				maxFieldSize_ = max;
+				propertyChangeSupport_.firePropertyChange("maxRows", currentMaxFieldSize, maxFieldSize_);
+			}
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setMaxFieldSize].methodExit();
+		}
+	}
+
+	public void setMaxRows(int maxrows) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setMaxRows].methodEntry();
+		try
+		{
+			if(maxrows < 0)
+			{
+				throw Messages.createSQLException(locale_, "invalid_maxRows_value", null);
+			}
+			if(maxrows < getFetchSize())
+			{
+				throw Messages.createSQLException(locale_, "maxRows_too_small_value", null);
+			}
+			else
+			{
+				int currentMaxRows;
+				try
+				{
+					currentMaxRows = getMaxRows();
+				}
+				catch(NullPointerException nullpointerexception)
+				{
+					currentMaxRows = 0;
+				}
+				if(currentMaxRows != maxrows)
+				{
+					maxRows_ = maxrows;
+					prepStmt_.setMaxRows(maxRows_);
+					propertyChangeSupport_.firePropertyChange("maxRows", currentMaxRows, maxrows);
+				}
+				return;
+			}
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setMaxRows].methodExit();
+		}
+	}
+
+	public void setNull(int parameterIndex, int sqlType) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setNull_II].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_setNull_II].methodParameters(
+										  Integer.toString(parameterIndex)+","+Integer.toString(sqlType));
+		try
+		{
+			validateSetInvocation(parameterIndex);
+			Object paramObj[] = new Object[2];
+			paramObj[0] = null;
+			paramObj[1] = sqlType;
+			parameters_.put(parameterIndex - 1, paramObj);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setNull_II].methodExit();
+		}
+	}
+	
+	public void setNull(int parameterIndex, int sqlType, String typeName) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setNull_IIL].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_setNull_IIL].methodParameters(
+										  Integer.toString(parameterIndex)+","+Integer.toString(sqlType)+","+typeName);
+		try
+		{
+			validateSetInvocation(parameterIndex);
+			Object paramObj[] = new Object[3];
+			paramObj[0] = null;
+			paramObj[1] = sqlType;
+			paramObj[2] = typeName;
+			parameters_.put(parameterIndex - 1, paramObj);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setNull_IIL].methodExit();
+		}
+	}
+
+	public void setObject(int parameterIndex, Object x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setObject_IL].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_setObject_IL].methodParameters(
+										  Integer.toString(parameterIndex)+",?");
+		try
+		{
+			if (x == null)
+			{
+				setNull(parameterIndex, Types.NULL);
+			}
+			else
+			{
+				validateSetInvocation(parameterIndex);
+				parameters_.put(parameterIndex - 1, x);
+			}
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setObject_IL].methodExit();
+		}
+	}
+
+	public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setObject_ILI].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_setObject_ILI].methodParameters(
+										  Integer.toString(parameterIndex)+",?,"+Integer.toString(targetSqlType));
+		try
+		{
+			if (x == null)
+			{
+				setNull(parameterIndex, Types.NULL);
+			}
+			else
+			{
+				validateSetInvocation(parameterIndex);
+				Object paramObj[] = new Object[2];
+				paramObj[0] = x;
+				paramObj[1] = targetSqlType;
+				parameters_.put(parameterIndex - 1, paramObj);
+			}
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setObject_ILI].methodExit();
+		}
+	}
+
+	public void setObject(int parameterIndex, Object x, int targetSqlType, int scale) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setObject_ILII].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_setObject_ILII].methodParameters(
+										  Integer.toString(parameterIndex)+",?,"+Integer.toString(targetSqlType)+
+										  ","+Integer.toString(scale));
+		try
+		{
+			if (x == null)
+			{
+				setNull(parameterIndex, Types.NULL);
+			}
+			else
+			{
+				validateSetInvocation(parameterIndex);
+				Object paramObj[] = new Object[3];
+				paramObj[0] = x;
+				paramObj[1] = targetSqlType;
+				paramObj[2] = scale;
+				parameters_.put(parameterIndex - 1, paramObj);
+			}
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setObject_ILII].methodExit();
+		}
+	}
+
+	public void setPassword(String password)
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setPassword].methodEntry();
+		try
+		{
+			String currentPassword = password_;
+			if(currentPassword != null)
+			{
+				if(!currentPassword.equals(password))
+				{
+					password_ = password;
+					conn_ = null;
+					prepStmt_ = null;
+					resultSet_ = null;
+					propertyChangeSupport_.firePropertyChange("password", currentPassword, password);
+				}
+			} 
+			else
+			{
+				password_ = password;
+				propertyChangeSupport_.firePropertyChange("password", currentPassword, password);
+			}
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setPassword].methodExit();
+		}
+	}
+
+	public void setQueryTimeout(int seconds) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setQueryTimeout].methodEntry();
+		try
+		{
+			if (seconds < 0)
+				throw Messages.createSQLException(locale_, "invalid_queryTimeout_value", null);
+			queryTimeout_ = seconds;
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setQueryTimeout].methodExit();
+		}
+	}
+
+	public void setReadOnly(boolean readOnly)
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setReadOnly].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_setReadOnly].methodParameters(
+										  "readOnly=" + readOnly);
+		try
+		{
+			readOnly_ = readOnly;
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setReadOnly].methodExit();
+		}
+	}
+
+	public void setRef(int parameterIndex, Ref x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setRef].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_setRef].methodParameters(
+										  Integer.toString(parameterIndex)+",?");
+		try
+		{
+			validateSetInvocation(parameterIndex);
+			Messages.throwUnsupportedFeatureException(locale_, "setRef()");
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setRef].methodExit();
+		}
+	}
+
+	public void setShort(int parameterIndex, short x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setShort].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_setShort].methodParameters(
+										  Integer.toString(parameterIndex)+","+Short.toString(x));
+		try
+		{
+			validateSetInvocation(parameterIndex);
+			parameters_.put(parameterIndex - 1, x);
+		}		
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setShort].methodExit();
+		}
+	}
+
+	public void setString(int parameterIndex, String s) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setString].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_setString].methodParameters(
+										  Integer.toString(parameterIndex)+","+s);
+		try
+		{
+			validateSetInvocation(parameterIndex);
+			parameters_.put(parameterIndex - 1, s);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setString].methodExit();
+		}
+	}
+
+	public void setTime(int parameterIndex, Time x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setTime_IL].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_setTime_IL].methodParameters(
+										  Integer.toString(parameterIndex)+",?");
+		try
+		{
+			validateSetInvocation(parameterIndex);
+			parameters_.put(parameterIndex - 1, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setTime_IL].methodExit();
+		}
+	}
+
+	public void setTime(int parameterIndex, Time x, Calendar cal) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setTime_ILL].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_setTime_ILL].methodParameters(
+										  Integer.toString(parameterIndex)+",?,?");
+		try
+		{
+			validateSetInvocation(parameterIndex);
+			Object paramObj[] = new Object[2];
+			paramObj[0] = x;
+			paramObj[1] = cal;
+			parameters_.put(parameterIndex - 1, paramObj);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setTime_ILL].methodExit();
+		}
+	}
+
+	public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setTimestamp_IL].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_setTimestamp_IL].methodParameters(
+										  Integer.toString(parameterIndex)+",?");
+		try
+		{
+			validateSetInvocation(parameterIndex);
+			parameters_.put(parameterIndex - 1, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setTimestamp_IL].methodExit();
+		}
+	}
+
+	public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setTimestamp_ILL].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_setTimestamp_ILL].methodParameters(
+										  Integer.toString(parameterIndex)+",?,?");
+		try
+		{
+			validateSetInvocation(parameterIndex);
+			Object paramObj[] = new Object[2];
+			paramObj[0] = x;
+			paramObj[1] = cal;
+			parameters_.put(parameterIndex - 1, paramObj);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setTimestamp_ILL].methodExit();
+		}
+	}
+
+	public void setTransactionIsolation(int trans_isolation) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setTransactionIsolation].methodEntry();
+		if (JdbcDebugCfg.traceActive) debug[methodId_setTransactionIsolation].methodParameters("trans_isolation = " + trans_isolation);
+		try
+		{
+			if(isolation_ != trans_isolation)
+			{
+				int currentIsolation = isolation_;
+				if (JdbcDebugCfg.traceActive)
+					debug[methodId_setTransactionIsolation].methodParameters("prev transaction isolation = " + currentIsolation);
+
+				if(conn_ != null)
+				{
+					conn_.setTransactionIsolation(trans_isolation);
+				}
+				isolation_ = trans_isolation;
+				propertyChangeSupport_.firePropertyChange("transactionIsolation", currentIsolation, trans_isolation);
+			}
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setTransactionIsolation].methodExit();
+		}
+	}
+
+	public void setType(int type) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setType].methodEntry();
+		try
+		{
+		/* Desc : The variable type is validated for the supported resultset types */  
+		if(type == ResultSet.TYPE_FORWARD_ONLY || type == ResultSet.TYPE_SCROLL_INSENSITIVE || type== ResultSet.TYPE_SCROLL_SENSITIVE)
+		{ 
+			int currentRowSetType = rowSetType_;
+			if(currentRowSetType != type)
+			{
+				rowSetType_ = type;
+				propertyChangeSupport_.firePropertyChange("type", currentRowSetType, type);
+			}
+		}
+		else
+		{
+			throw new SQLException("Error : Unsupported SQLMXJdbcRowSet Type");
+		} 
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setType].methodExit();
+		}
+	}
+
+	public void setTypeMap(Map<String,Class<?>> map)
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setTypeMap].methodEntry();
+		try
+		{
+			map_ = map;
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setTypeMap].methodExit();
+		}
+	}
+
+	public void setUrl(String url) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setUrl].methodEntry();
+		try
+		{
+			if(URL_ != null)
+			{
+				if(!URL_.equals(url))
+				{
+					String currentURL = URL_;
+					URL_ = url;
+					conn_ = null;
+					prepStmt_ = null;
+					resultSet_ = null;
+					propertyChangeSupport_.firePropertyChange("url", currentURL, url);
+				}
+			} 
+			else
+			{
+				URL_ = url;
+				propertyChangeSupport_.firePropertyChange("url", null, url);
+			}
+			// Set dataSourceName_ to null such that connections
+			// are established using URL_
+			dataSourceName_ = null;
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setUrl].methodExit();
+		}
+	}
+
+	public void setUsername(String uname)
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setUsername].methodEntry();
+		try
+		{
+			String currentUsername = username_;
+			if(currentUsername != null)
+			{
+				if(!currentUsername.equals(uname))
+				{
+					username_ = uname;
+					conn_ = null;
+					prepStmt_ = null;
+					resultSet_ = null;
+					propertyChangeSupport_.firePropertyChange("username", currentUsername, uname);
+				}
+			} 
+			else
+			{
+				username_ = uname;
+				propertyChangeSupport_.firePropertyChange("password", currentUsername, uname);
+			}
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setUsername].methodExit();
+		}
+	}
+
+	public void updateArray(int columnIndex, Array x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateArray_IL].methodEntry();
+		try
+		{
+			checkValidState();
+			checkTypeConcurrency();
+			resultSet_.updateArray(columnIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateArray_IL].methodExit();
+		}
+	}
+
+	public void updateArray(String columnName, Array x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateArray_LL].methodEntry();
+		try
+		{
+			int colIndex = findColumn(columnName);
+			checkTypeConcurrency();
+			resultSet_.updateArray(colIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateArray_LL].methodExit();
+		}
+	}
+
+	public void updateAsciiStream(int columnIndex, InputStream x, int length) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateAsciiStream_ILI].methodEntry();
+		try
+		{
+			checkValidState();
+			checkTypeConcurrency();
+			resultSet_.updateAsciiStream(columnIndex, x, length);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateAsciiStream_ILI].methodExit();
+		}
+	}
+	  
+	public void updateAsciiStream(String columnName, InputStream x, int length) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateAsciiStream_LLI].methodEntry();
+		try
+		{
+			int colIndex = findColumn(columnName);
+			checkTypeConcurrency();
+			resultSet_.updateAsciiStream(colIndex, x, length);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateAsciiStream_LLI].methodExit();
+		}
+	}
+	  
+	public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateBigDecimal_IL].methodEntry();
+		try
+		{
+			checkValidState();
+			checkTypeConcurrency();
+			resultSet_.updateBigDecimal(columnIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateBigDecimal_IL].methodExit();
+		}
+	}
+	  
+	public void updateBigDecimal(String columnName, BigDecimal x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateBigDecimal_LL].methodEntry();
+		try
+		{
+			int colIndex = findColumn(columnName);
+			checkTypeConcurrency();
+			resultSet_.updateBigDecimal(colIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateBigDecimal_LL].methodExit();
+		}
+	}
+	  
+	public void updateBinaryStream(int columnIndex, InputStream x, int length) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateBinaryStream_ILI].methodEntry();
+		try
+		{
+			checkValidState();
+			checkTypeConcurrency();
+			resultSet_.updateBinaryStream(columnIndex, x, length);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateBinaryStream_ILI].methodExit();
+		}
+	}
+	  
+	public void updateBinaryStream(String columnName, InputStream x, int length) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateBinaryStream_LLI].methodEntry();
+		try
+		{
+			int colIndex = findColumn(columnName);
+			checkTypeConcurrency();
+			resultSet_.updateBinaryStream(colIndex, x, length);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateBinaryStream_LLI].methodExit();
+		}
+	}
+
+	public void updateBlob(int columnIndex, Blob x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateBlob_IL].methodEntry();
+		try
+		{
+			checkValidState();
+			checkTypeConcurrency();
+			resultSet_.updateBlob(columnIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateBlob_IL].methodExit();
+		}
+	}
+
+	public void updateBlob(String columnName, Blob x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateBlob_LL].methodEntry();
+		try
+		{
+			int colIndex = findColumn(columnName);
+			checkTypeConcurrency();
+			resultSet_.updateBlob(colIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateBlob_LL].methodExit();
+		}
+	}
+	  
+	public void updateBoolean(int columnIndex, boolean x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateBoolean_IZ].methodEntry();
+		try
+		{
+			checkValidState();
+			checkTypeConcurrency();
+			resultSet_.updateBoolean(columnIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateBoolean_IZ].methodExit();
+		}
+	}
+	  
+	public void updateBoolean(String columnName, boolean x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateBoolean_LZ].methodEntry();
+		try
+		{
+			int colIndex = findColumn(columnName);
+			checkTypeConcurrency();
+			resultSet_.updateBoolean(colIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateBoolean_LZ].methodExit();
+		}
+	}
+	  
+	public void updateByte(int columnIndex, byte x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateByte_IZ].methodEntry();
+		try
+		{
+			checkValidState();
+			checkTypeConcurrency();
+			resultSet_.updateByte(columnIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateByte_IZ].methodExit();
+		}
+	}
+	  
+	public void updateByte(String columnName, byte x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateByte_LZ].methodEntry();
+		try
+		{
+			int colIndex = findColumn(columnName);
+			checkTypeConcurrency();
+			resultSet_.updateByte(colIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateByte_LZ].methodExit();
+		}
+	}
+	  
+	public void updateBytes(int columnIndex, byte[] x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateBytes_IZ].methodEntry();
+		try
+		{
+			checkValidState();
+			checkTypeConcurrency();
+			resultSet_.updateBytes(columnIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateBytes_IZ].methodExit();
+		}
+	}
+	  
+	public void updateBytes(String columnName, byte[] x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateBytes_LZ].methodEntry();
+		try
+		{
+			int colIndex = findColumn(columnName);
+			checkTypeConcurrency();
+			resultSet_.updateBytes(colIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateBytes_LZ].methodExit();
+		}
+	}
+	  
+	public void updateCharacterStream(int columnIndex, Reader x, int length) throws SQLException 
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateCharacterStream_ILI].methodEntry();
+		try
+		{
+			checkValidState();
+			checkTypeConcurrency();
+			resultSet_.updateCharacterStream(columnIndex, x, length);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateCharacterStream_ILI].methodExit();
+		}
+	}
+	  
+	public void updateCharacterStream(String columnName, Reader x, int length) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateCharacterStream_LLI].methodEntry();
+		try
+		{
+			int colIndex = findColumn(columnName);
+			checkTypeConcurrency();
+			resultSet_.updateCharacterStream(colIndex, x, length);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateCharacterStream_LLI].methodExit();
+		}
+	}
+	  
+	public void updateClob(int columnIndex, Clob x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateClob_IL].methodEntry();
+		try
+		{
+			checkValidState();
+			checkTypeConcurrency();
+			resultSet_.updateClob(columnIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateClob_IL].methodExit();
+		}
+	}
+
+	public void updateClob(String columnName, Clob x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateClob_LL].methodEntry();
+		try
+		{
+			int colIndex = findColumn(columnName);
+			checkTypeConcurrency();
+			resultSet_.updateClob(colIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateClob_LL].methodExit();
+		}
+	}
+	
+	public void updateDate(int columnIndex, Date x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateDate_IL].methodEntry();
+		try
+		{
+			checkValidState();
+			checkTypeConcurrency();
+			resultSet_.updateDate(columnIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateDate_IL].methodExit();
+		}
+	}
+	  
+	public void updateDate(String columnName, Date x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateDate_LL].methodEntry();
+		try
+		{
+			int colIndex = findColumn(columnName);
+			checkTypeConcurrency();
+			resultSet_.updateDate(colIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateDate_LL].methodExit();
+		}
+	}
+	  
+	public void updateDouble(int columnIndex, double x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateDouble_ID].methodEntry();
+		try
+		{
+			checkValidState();
+			checkTypeConcurrency();
+			resultSet_.updateDouble(columnIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateDouble_ID].methodExit();
+		}
+	}
+	  
+	public void updateDouble(String columnName, double x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateDouble_LD].methodEntry();
+		try
+		{
+			int colIndex = findColumn(columnName);
+			checkTypeConcurrency();
+			resultSet_.updateDouble(colIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateDouble_LD].methodExit();
+		}
+	}
+	  
+	public void updateFloat(int columnIndex, float x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateFloat_IF].methodEntry();
+		try
+		{
+			checkValidState();
+			checkTypeConcurrency();
+			resultSet_.updateFloat(columnIndex, x);	
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateFloat_IF].methodExit();
+		}
+	}
+	  
+	public void updateFloat(String columnName, float x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateFloat_LF].methodEntry();
+		try
+		{
+			int colIndex = findColumn(columnName);
+			checkTypeConcurrency();
+			resultSet_.updateFloat(colIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateFloat_LF].methodExit();
+		}
+	}
+	  
+	public void updateInt(int columnIndex, int x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateInt_II].methodEntry();
+		try
+		{
+			checkValidState();
+			checkTypeConcurrency();
+			resultSet_.updateInt(columnIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateInt_II].methodExit();
+		}
+	}
+	  
+	public void updateInt(String columnName, int x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateInt_LI].methodEntry();
+		try
+		{
+			int colIndex = findColumn(columnName);
+			checkTypeConcurrency();
+			resultSet_.updateInt(colIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateInt_LI].methodExit();
+		}
+	}
+	  
+	public void updateLong(int columnIndex, long x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateLong_IJ].methodEntry();
+		try
+		{
+			checkValidState();
+			checkTypeConcurrency();
+			resultSet_.updateLong(columnIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateLong_IJ].methodExit();
+		}
+	}
+	  
+	public void updateLong(String columnName, long x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateLong_LJ].methodEntry();
+		try
+		{
+			int colIndex = findColumn(columnName);
+			checkTypeConcurrency();
+			resultSet_.updateLong(colIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateLong_LJ].methodExit();
+		}
+	}
+	  
+	public void updateNull(int columnIndex) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateNull_I].methodEntry();
+		try
+		{
+			checkValidState();
+			checkTypeConcurrency();
+			resultSet_.updateNull(columnIndex);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateNull_I].methodExit();
+		}
+	}
+	  
+	public void updateNull(String columnName) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateNull_L].methodEntry();
+		try
+		{
+			int colIndex = findColumn(columnName);
+			checkTypeConcurrency();
+			resultSet_.updateNull(colIndex);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateNull_L].methodExit();
+		}
+	}
+	  
+	public void updateObject(int columnIndex, Object x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateObject_IL].methodEntry();
+		try
+		{
+			checkValidState();
+			checkTypeConcurrency();
+			resultSet_.updateObject(columnIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateObject_IL].methodExit();
+		}
+	}
+	  
+	public void updateObject(int columnIndex, Object x, int scale) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateObject_ILI].methodEntry();
+		try
+		{
+			checkValidState();
+			checkTypeConcurrency();
+			resultSet_.updateObject(columnIndex, x, scale);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateObject_ILI].methodExit();
+		}
+	}
+	
+	public void updateObject(String columnName, Object x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateObject_LL].methodEntry();
+		try
+		{
+			int colIndex = findColumn(columnName);
+			checkTypeConcurrency();
+			resultSet_.updateObject(colIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateObject_LL].methodExit();
+		}
+	}
+	  
+	public void updateObject(String columnName, Object x, int scale) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateObject_LLI].methodEntry();
+		try
+		{
+			int colIndex = findColumn(columnName);
+			checkTypeConcurrency();
+			resultSet_.updateObject(colIndex, x, scale);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateObject_LLI].methodExit();
+		}
+	}
+	 
+	public void updateRef(int columnIndex, Ref x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateRef_IL].methodEntry();
+		try
+		{
+			checkValidState();
+			checkTypeConcurrency();
+			resultSet_.updateRef(columnIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateRef_IL].methodExit();
+		}
+	}
+
+	public void updateRef(String columnName, Ref x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateRef_LL].methodEntry();
+		try
+		{
+			int colIndex = findColumn(columnName);
+			checkTypeConcurrency();
+			resultSet_.updateRef(colIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateRef_LL].methodExit();
+		}
+	}
+
+	public void updateRow() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateRow].methodEntry();
+		try
+		{
+			checkValidState();
+			resultSet_.updateRow();
+			notifyRowChanged();
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateRow].methodExit();
+		}
+	}
+
+	public void updateShort(int columnIndex, short x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateShort_IS].methodEntry();
+		try
+		{
+			checkValidState();
+			checkTypeConcurrency();
+			resultSet_.updateShort(columnIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateShort_IS].methodExit();
+		}
+	}
+	  
+	public void updateShort(String columnName, short x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateShort_LS].methodEntry();
+		try
+		{
+			int colIndex = findColumn(columnName);
+			checkTypeConcurrency();
+			resultSet_.updateShort(colIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateShort_LS].methodExit();
+		}
+	}
+	  
+	public void updateString(int columnIndex, String x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateString_IL].methodEntry();
+		try
+		{
+			checkValidState();
+			checkTypeConcurrency();
+			resultSet_.updateString(columnIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateString_IL].methodExit();
+		}
+	}
+	  
+	public void updateString(String columnName, String x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateString_LL].methodEntry();
+		try
+		{
+			int colIndex = findColumn(columnName);
+			checkTypeConcurrency();
+			resultSet_.updateString(colIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateString_LL].methodExit();
+		}
+	}
+	  
+	public void updateTime(int columnIndex, Time x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateTime_IL].methodEntry();
+		try
+		{
+			checkValidState();
+			checkTypeConcurrency();
+			resultSet_.updateTime(columnIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateTime_IL].methodExit();
+		}
+	}
+	  
+	public void updateTime(String columnName, Time x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateTime_LL].methodEntry();
+		try
+		{
+			int colIndex = findColumn(columnName);
+			checkTypeConcurrency();
+			resultSet_.updateTime(colIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateTime_LL].methodExit();
+		}
+	}
+	  
+	public void updateTimestamp(int columnIndex, Timestamp x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateTimestamp_IL].methodEntry();
+		try
+		{
+			checkValidState();
+			checkTypeConcurrency();
+			resultSet_.updateTimestamp(columnIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateTimestamp_IL].methodExit();
+		}
+	}
+	  
+	public void updateTimestamp(String columnName, Timestamp x) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_updateTimestamp_LL].methodEntry();
+		try
+		{
+			int colIndex = findColumn(columnName);
+			checkTypeConcurrency();
+			resultSet_.updateTimestamp(colIndex, x);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_updateTimestamp_LL].methodExit();
+		}
+	}
+	  
+	public boolean wasNull() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_wasNull].methodEntry();
+		try
+		{
+			checkValidState();
+			return resultSet_.wasNull();
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_wasNull].methodExit();
+		}
+	}
+
+	// Joinable methods
+	public void unsetMatchColumn(int ai[]) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_unsetMatchColumn_V].methodEntry();
+		try
+		{
+			for(int j = 0; j < ai.length; j++)
+			{
+				if(ai[j] != iMatchColumns_.get(j))
+				{
+					throw Messages.createSQLException(locale_, "match_columns_mismatch" ,null);
+				}
+			}
+			for(int k = 0; k < ai.length; k++)
+			{
+				iMatchColumns_.set(k, -1);
+			}
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_unsetMatchColumn_V].methodExit();
+		}
+	}
+
+	public void unsetMatchColumn(String as[]) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_unsetMatchColumn_L].methodEntry();
+		try
+		{
+			for(int i = 0; i < as.length; i++)
+			{
+				if(!as[i].equals(strMatchColumns_.get(i)))
+				{
+					throw Messages.createSQLException(locale_, "match_columns_mismatch" ,null);
+				}
+			}
+			strMatchColumns_.clear();
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_unsetMatchColumn_L].methodExit();
+		}
+	}
+
+	public String[] getMatchColumnNames() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getMatchColumnNames].methodEntry();
+		try
+		{
+			if(strMatchColumns_.get(0) == null)
+				throw Messages.createSQLException(locale_, "set_match_columns" ,null);
+			else
+			{
+				String as[] = new String[strMatchColumns_.size()];
+				strMatchColumns_.copyInto(as);
+				return as;
+			}
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getMatchColumnNames].methodExit();
+		}
+	}
+
+	public int[] getMatchColumnIndexes() throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_getMatchColumnIndexes].methodEntry();
+		try
+		{
+			if(iMatchColumns_.get(0) == -1)
+				throw Messages.createSQLException(locale_, "set_match_columns" ,null);
+
+			int ai[] = new int[iMatchColumns_.size()];
+			for(int j = 0; j < ai.length; j++)
+			{
+				ai[j] = iMatchColumns_.get(j);
+			}
+			return ai;
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_getMatchColumnIndexes].methodExit();
+		}
+	}
+
+	public void setMatchColumn(int ai[]) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setMatchColumn_V].methodEntry();
+		try
+		{
+			for(int i = 0; i < ai.length; i++)
+			{
+				if(ai[i] < 0)
+					throw Messages.createSQLException(locale_, "match_columns_nonzero" ,null);
+			}
+			for(int j = 0; j < ai.length; j++)
+			{
+				iMatchColumns_.add(j, new Integer(ai[j]));
+			}
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setMatchColumn_V].methodExit();
+		}
+	}
+
+	public void setMatchColumn(String as[]) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setMatchColumn_L].methodEntry();
+		try
+		{
+			for(int i = 0; i < as.length; i++)
+			{
+				if(as[i] == null || as[i].equals(""))
+					throw Messages.createSQLException(locale_, "match_columns_empty" ,null);
+			}
+			for(int j = 0; j < as.length; j++)
+			{
+				strMatchColumns_.add(j, as[j]);
+			}
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setMatchColumn_L].methodExit();
+		}
+	}
+
+	public void setMatchColumn(int i) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setMatchColumn_I].methodEntry();
+		try
+		{
+			if(i < 0)
+				throw Messages.createSQLException(locale_, "match_columns_nonzero" ,null);
+			else
+				iMatchColumns_.set(0, i);
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setMatchColumn_I].methodExit();
+		}
+	}
+
+	public void setMatchColumn(String s) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_setMatchColumn_S].methodEntry();
+		try
+		{
+			if(s == null || s.equals(""))
+				throw Messages.createSQLException(locale_, "match_columns_empty" ,null);
+			else
+			{
+				s = s.trim();
+				strMatchColumns_.set(0, s);
+			}
+		}
+		finally
+		{
+			if (JdbcDebugCfg.entryActive) debug[methodId_setMatchColumn_S].methodExit();
+		}
+	}
+
+	public void unsetMatchColumn(int i) throws SQLException
+	{
+		if (JdbcDebugCfg.entryActive) debug[methodId_unsetMatchColumn_I].methodEntry();
+		try
+		{
+			if(!iMatchColumns_.get(0).equals(i))
+				throw Messages.createSQLException(locale_, "unset_match_

<TRUNCATED>