[22/60] incubator-trafodion git commit: TRAFODION-1933 JDBC TYpe4 driver build scripts migrated to use maven instead of ant

[db...@apache.org]

http://git-wip-us.apache.org/repos/asf/incubator-trafodion/blob/72e17019/core/conn/jdbcT4/src/main/java/org/trafodion/jdbc/t4/TrafT4PreparedStatement.java
----------------------------------------------------------------------
diff --git a/core/conn/jdbcT4/src/main/java/org/trafodion/jdbc/t4/TrafT4PreparedStatement.java b/core/conn/jdbcT4/src/main/java/org/trafodion/jdbc/t4/TrafT4PreparedStatement.java
new file mode 100644
index 0000000..489904f
--- /dev/null
+++ b/core/conn/jdbcT4/src/main/java/org/trafodion/jdbc/t4/TrafT4PreparedStatement.java
@@ -0,0 +1,2558 @@
+// @@@ 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 @@@
+
+package org.trafodion.jdbc.t4;
+
+import java.io.InputStream;
+import java.io.Reader;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.net.URL;
+import java.nio.ByteBuffer;
+import java.sql.Array;
+import java.sql.BatchUpdateException;
+import java.sql.Blob;
+import java.sql.Clob;
+import java.sql.DatabaseMetaData;
+import java.sql.Date;
+import java.sql.NClob;
+import java.sql.ParameterMetaData;
+import java.sql.Ref;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.RowId;
+import java.sql.SQLException;
+import java.sql.SQLXML;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.sql.Types;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.Locale;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+
+public class TrafT4PreparedStatement extends TrafT4Statement implements java.sql.PreparedStatement {
+	// java.sql.PreparedStatement interface methods
+	public void addBatch() throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "addBatch", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("addBatch");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+
+		if (inputDesc_ == null) {
+			return;
+		}
+
+		// Check if all parameters are set for current set
+		checkIfAllParamsSet();
+		// Add to the number of Rows Count
+		if (rowsValue_ == null) {
+			rowsValue_ = new ArrayList();
+		}
+		rowsValue_.add(paramsValue_);
+		paramRowCount_++;
+		paramsValue_ = new Object[inputDesc_.length];
+		if (isAnyLob_ && (lobObjects_ == null)) {
+			lobObjects_ = new ArrayList();
+			// Clear the isValueSet_ flag in inputDesc_ and add the lob objects
+			// to the lobObject List
+		}
+		for (int i = 0; i < inputDesc_.length; i++) {
+			// If isAnyLob_ is false: inputDesc_.paramValue_ for all
+			// parameters should be null
+			// If isAnyLob_ is true: one or more inputDesc_.parmValue will not
+			// be null, based on the number of LOB columns in the query
+			if (inputDesc_[i].paramValue_ != null) {
+				lobObjects_.add(inputDesc_[i].paramValue_);
+				inputDesc_[i].paramValue_ = null;
+			}
+			inputDesc_[i].isValueSet_ = false;
+		}
+	}
+
+	public void clearBatch() throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "clearBatch", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("clearBatch");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+
+		if (inputDesc_ == null) {
+			return;
+		}
+		if (rowsValue_ != null) {
+			rowsValue_.clear();
+		}
+		if (lobObjects_ != null) {
+			lobObjects_.clear();
+		}
+		paramRowCount_ = 0;
+		// Clear the isValueSet_ flag in inputDesc_
+		for (int i = 0; i < inputDesc_.length; i++) {
+			inputDesc_[i].isValueSet_ = false;
+			paramsValue_[i] = null;
+			inputDesc_[i].paramValue_ = null;
+		}
+		isAnyLob_ = false;
+		batchRowCount_ = new int[] {};
+	}
+
+	public void clearParameters() throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "clearParameters", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("clearParameters");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		// Clear the isValueSet_ flag in inputDesc_
+		if (inputDesc_ == null) {
+			return;
+		}
+
+		for (int i = 0; i < inputDesc_.length; i++) {
+			inputDesc_[i].isValueSet_ = false;
+			paramsValue_[i] = null;
+			inputDesc_[i].paramValue_ = null;
+		}
+		isAnyLob_ = false;
+	}
+
+	public void close() throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "close", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("close");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+
+		if (isClosed_) {
+			return;
+		}
+		try {
+			if (connection_._isClosed() == false) {
+				if (!connection_.isStatementCachingEnabled()) {
+					super.close();
+				} else {
+					logicalClose();
+				}
+			}
+		} catch (SQLException e) {
+			performConnectionErrorChecks(e);
+			throw e;
+		} finally {
+			isClosed_ = true;
+			if (!connection_.isStatementCachingEnabled()) {
+				connection_.removeElement(pRef_);
+			}
+		}
+
+	}
+
+	public boolean execute() throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "execute", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("execute");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		Object[] valueArray = null;
+		int inDescLength = 0;
+
+		validateExecuteInvocation();
+
+		// *******************************************************************
+		// * If LOB is involved with autocommit enabled we throw an exception
+		// *******************************************************************
+		if (isAnyLob_ && (connection_.getAutoCommit())) {
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(),
+					"invalid_lob_commit_state", null);
+		}
+		if (inputDesc_ != null) {
+			if (!usingRawRowset_)
+				valueArray = getValueArray();
+			inDescLength = inputDesc_.length;
+		}
+
+		execute(paramRowCount_ + 1, inDescLength, valueArray, queryTimeout_, isAnyLob_); // LOB
+		// Support
+		// - SB
+		// 9/28/04
+
+		// if (resultSet_[result_set_offset] != null)
+		if (resultSet_ != null && resultSet_[result_set_offset] != null) {
+			return true;
+		} else {
+			if (isAnyLob_) {
+
+
+			}
+			return false;
+		}
+	}
+
+	public int[] executeBatch() throws SQLException, BatchUpdateException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "executeBatch", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("executeBatch");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+
+		try {
+			clearWarnings();
+			HPT4Exception se;
+			Object[] valueArray = null;
+
+			if (inputDesc_ == null) {
+				se = HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(),
+						"batch_command_failed", null);
+				throw new BatchUpdateException(se.getMessage(), se.getSQLState(), new int[0]);
+			}
+			if (sqlStmtType_ == TRANSPORT.TYPE_SELECT) {
+				se = HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(),
+						"select_in_batch_not_supported", null);
+				throw new BatchUpdateException(se.getMessage(), se.getSQLState(), new int[0]);
+			}
+			if (connection_._isClosed()) {
+				se = HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(), "invalid_connection",
+						null);
+				connection_.closeErroredConnection(se);
+				throw new BatchUpdateException(se.getMessage(), se.getSQLState(), new int[0]);
+			}
+			if (isAnyLob_ && (connection_.getAutoCommit())) {
+				throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(),
+						"invalid_lob_commit_state", null);
+			}
+
+			int prc = usingRawRowset_ ? (paramRowCount_ + 1) : paramRowCount_;
+
+			if (paramRowCount_ < 1) {
+				if (!connection_.props_.getDelayedErrorMode()) {
+					return (new int[] {});
+				}
+			} 
+
+			try {
+				if (!usingRawRowset_)
+					valueArray = getValueArray();
+
+				execute(prc, inputDesc_.length, valueArray, queryTimeout_, lobObjects_ != null);
+
+
+			} catch (SQLException e) {
+				BatchUpdateException be;
+				se = HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(),
+						"batch_command_failed", null);
+				if (batchRowCount_ == null) // we failed before execute
+				{
+					batchRowCount_ = new int[paramRowCount_];
+					Arrays.fill(batchRowCount_, -3);
+				}
+				be = new BatchUpdateException(se.getMessage(), se.getSQLState(), batchRowCount_);
+				be.setNextException(e);
+
+				throw be;
+			}
+
+			if (connection_.props_.getDelayedErrorMode()) {
+				_lastCount = paramRowCount_;
+			}
+
+			return batchRowCount_;
+		} finally {
+			clearBatch();
+		}
+	}
+
+	public ResultSet executeQuery() throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "executeQuery", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("executeQuery");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		Object[] valueArray = null;
+		int inDescLength = 0;
+
+		validateExecuteInvocation();
+		if (sqlStmtType_ != TRANSPORT.TYPE_SELECT) {
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(), "non_select_invalid",
+					null);
+		}
+
+		if (inputDesc_ != null) {
+			if (!usingRawRowset_)
+				valueArray = getValueArray();
+			inDescLength = inputDesc_.length;
+		}
+		execute(paramRowCount_ + 1, inDescLength, valueArray, queryTimeout_, isAnyLob_); // LOB
+		// Support
+		// - SB
+		// 9/28/04
+		return resultSet_[result_set_offset];
+	}
+
+	public int executeUpdate() throws SQLException {
+		long count = executeUpdate64();
+
+		if (count > Integer.MAX_VALUE)
+			this.setSQLWarning(null, "numeric_out_of_range", null);
+
+		return (int) count;
+	}
+
+	public long executeUpdate64() throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "executeUpdate", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("executeUpdate");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		Object[] valueArray = null;
+		int inDescLength = 0;
+
+		validateExecuteInvocation();
+		// if (sqlStmtType_ == TRANSPORT.TYPE_SELECT)
+		if (sqlStmtType_ == TRANSPORT.TYPE_SELECT && (ist_.stmtIsLock != true)) {
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(), "select_invalid", null);
+		}
+
+		if (usingRawRowset_ == false) {
+			if (inputDesc_ != null) {
+				if (!usingRawRowset_)
+					valueArray = getValueArray();
+				inDescLength = inputDesc_.length;
+			}
+		} else {
+			valueArray = this.paramsValue_; // send it along raw in case we need
+			// it
+			paramRowCount_ -= 1; // we need to make sure that paramRowCount
+			// stays exactly what we set it to since we
+			// add one during execute
+		}
+
+		// *******************************************************************
+		// * If LOB is involved with autocommit enabled we throw an exception
+		// *******************************************************************
+		if (isAnyLob_ && (connection_.getAutoCommit())) {
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(),
+					"invalid_lob_commit_state", null);
+		}
+
+		execute(paramRowCount_ + 1, inDescLength, valueArray, queryTimeout_, isAnyLob_); 
+		if (isAnyLob_) {
+
+
+		}
+		return ist_.getRowCount();
+	}
+
+	public ResultSetMetaData getMetaData() throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "getMetaData", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("getMetaData");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+
+		if (outputDesc_ != null) {
+			return new HPT4ResultSetMetaData(this, outputDesc_);
+		} else {
+			return null;
+		}
+	}
+
+	public ParameterMetaData getParameterMetaData() throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "getParameterMetaData", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("getParameterMetaData");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		if (inputDesc_ != null) {
+			return new HPT4ParameterMetaData(this, inputDesc_);
+		} else {
+			return null;
+		}
+	}
+
+	// JDK 1.2
+	public void setArray(int parameterIndex, Array x) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, x);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "setArray", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, x);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("setArray");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		validateSetInvocation(parameterIndex);
+		HPT4Messages.throwUnsupportedFeatureException(connection_.props_, connection_.getLocale(), "setArray()");
+	}
+
+	public void setAsciiStream(int parameterIndex, InputStream x, int length) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x, length);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "setAsciiStream", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x, length);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("setAsciiStream");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		int dataType;
+		long dataLocator;
+
+		validateSetInvocation(parameterIndex);
+
+		dataType = inputDesc_[parameterIndex - 1].dataType_;
+
+		switch (dataType) {
+
+			
+		case Types.CHAR:
+		case Types.VARCHAR:
+		case Types.LONGVARCHAR:
+		case Types.BINARY:  // At this time Database does not have
+			// this column data type 
+		case Types.VARBINARY:  // At this time Database does not
+			// have this column data type //#endif-java
+		case Types.LONGVARBINARY:  // At this time Database does not
+			// have this column data type 
+			byte[] buffer = new byte[length];
+			try {
+				x.read(buffer);
+			} catch (java.io.IOException e) {
+				Object[] messageArguments = new Object[1];
+				messageArguments[0] = e.getMessage();
+				throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(), "io_exception",
+						messageArguments);
+			}
+
+			try {
+				addParamValue(parameterIndex, new String(buffer, "ASCII"));
+			} catch (java.io.UnsupportedEncodingException e) {
+				Object[] messageArguments = new Object[1];
+				messageArguments[0] = e.getMessage();
+				throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(),
+						"unsupported_encoding", messageArguments);
+			}
+			break;
+		default:
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(),
+					"invalid_datatype_for_column", null);
+		}
+	}
+
+	public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "setBigDecimal", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("setBigDecimal");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+
+		validateSetInvocation(parameterIndex);
+		inputDesc_[parameterIndex - 1].checkValidNumericConversion(connection_.getLocale());
+
+		if (x != null) {
+			Utility.checkDecimalTruncation(parameterIndex, connection_.getLocale(), x,
+					inputDesc_[parameterIndex - 1].precision_, inputDesc_[parameterIndex - 1].scale_);
+			addParamValue(parameterIndex, x.toString());
+		} else {
+			addParamValue(parameterIndex, null);
+		}
+	}
+
+	public void setBinaryStream(int parameterIndex, InputStream x, int length) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x, length);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "setBinaryStream",
+					"setBinaryStream", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x, length);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("setBinaryStream");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		int dataType;
+		long dataLocator;
+
+		validateSetInvocation(parameterIndex);
+
+		dataType = inputDesc_[parameterIndex - 1].dataType_;
+
+		switch (dataType) {
+		
+
+		case Types.DOUBLE:
+		case Types.DECIMAL:
+		case Types.NUMERIC:
+		case Types.FLOAT:
+		case Types.BIGINT:
+		case Types.INTEGER:
+		case Types.SMALLINT:
+		case Types.TINYINT:
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(),
+					"invalid_datatype_for_column", null);
+		case Types.CHAR:
+		case Types.VARCHAR:
+		case Types.LONGVARCHAR:
+		case Types.BINARY: // At this time Database does not have
+			// this column data type 
+		case Types.VARBINARY:  // At this time Database does not
+			// have this column data type 
+		case Types.LONGVARBINARY:  // At this time Database does not
+			// have this column data type 
+			byte[] buffer2 = new byte[length];
+
+			try {
+				int temp = x.read(buffer2);
+			} catch (java.io.IOException e) {
+				Object[] messageArguments = new Object[1];
+				messageArguments[0] = e.getMessage();
+				throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(), "io_exception",
+						messageArguments);
+			}
+			addParamValue(parameterIndex, buffer2);
+			break;
+		default:
+			byte[] buffer = new byte[length];
+
+			try {
+				x.read(buffer);
+			} catch (java.io.IOException e) {
+				Object[] messageArguments = new Object[1];
+				messageArguments[0] = e.getMessage();
+				throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(), "io_exception",
+						messageArguments);
+			}
+
+			// addParamValue(parameterIndex, new String(buffer));
+			// just pass the raw buffer.
+			addParamValue(parameterIndex, buffer);
+		}
+	}
+
+	/*
+	 * Sets the designated parameter to the given <tt>Blob</tt> object. The
+	 * driver converts this to an SQL <tt>BLOB</tt> value when it sends it to
+	 * the database.
+	 * 
+	 * @param i the first parameter is 1, the second is 2, ... @param x a <tt>Blob</tt>
+	 * object that maps an SQL <tt>BLOB</tt> value
+	 * 
+	 * @throws SQLException invalid data type for column
+	 */
+	public void setBlob(int parameterIndex, Blob x) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "setBlob", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("setBlob");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		int dataType;
+		long dataLocator;
+
+		validateSetInvocation(parameterIndex);
+		dataType = inputDesc_[parameterIndex - 1].dataType_;
+		switch (dataType) {
+		
+			
+		default:
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(),
+					"invalid_datatype_for_column", null);
+		}
+	}
+
+	public void setBoolean(int parameterIndex, boolean x) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "setBoolean", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("setBoolean");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		validateSetInvocation(parameterIndex);
+		inputDesc_[parameterIndex - 1].checkValidNumericConversion(connection_.getLocale());
+		if (x) {
+			addParamValue(parameterIndex, "1"); // true
+		} else {
+			addParamValue(parameterIndex, "0"); // false
+		}
+	}
+
+	public void setByte(int parameterIndex, byte x) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "setByte", "setByte", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("setByte");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		validateSetInvocation(parameterIndex);
+		inputDesc_[parameterIndex - 1].checkValidNumericConversion(connection_.getLocale());
+		addParamValue(parameterIndex, Byte.toString(x));
+	}
+
+	public void setBytes(int parameterIndex, byte[] x) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "setBytes", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("setBytes");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		int dataType;
+		long dataLocator;
+
+		byte[] tmpArray = new byte[x.length];
+		System.arraycopy(x, 0, tmpArray, 0, x.length);
+		validateSetInvocation(parameterIndex);
+		dataType = inputDesc_[parameterIndex - 1].dataType_;
+		switch (dataType) {
+		
+			
+		case Types.CHAR:
+		case Types.VARCHAR:
+		case Types.LONGVARCHAR:
+		case Types.BINARY:
+		case Types.VARBINARY:
+		case Types.LONGVARBINARY:
+			addParamValue(parameterIndex, tmpArray);
+			break;
+		default:
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(), "restricted_data_type",
+					null);
+		}
+	}
+
+	public void setCharacterStream(int parameterIndex, Reader reader, int length) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, reader, length);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "setCharacterStream", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, reader, length);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("setCharacterStream");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		char[] value;
+		int dataType;
+		long dataLocator;
+
+		validateSetInvocation(parameterIndex);
+		dataType = inputDesc_[parameterIndex - 1].dataType_;
+		switch (dataType) {
+		
+
+		case Types.DECIMAL:
+		case Types.DOUBLE:
+		case Types.FLOAT:
+		case Types.NUMERIC:
+		case Types.BIGINT:
+		case Types.INTEGER:
+		case Types.SMALLINT:
+		case Types.TINYINT:
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(),
+					"invalid_datatype_for_column", null);
+
+		default:
+			value = new char[length];
+			try {
+				int valuePos = reader.read(value);
+				if (valuePos < 1) {
+					Object[] messageArguments = new Object[1];
+					messageArguments[0] = "No data to read from the Reader";
+					throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(), "io_exception",
+							messageArguments);
+				}
+
+				while (valuePos < length) {
+					char temp[] = new char[length - valuePos];
+					int tempReadLen = reader.read(temp, 0, length - valuePos);
+					System.arraycopy(temp, 0, value, valuePos, tempReadLen);
+					valuePos += tempReadLen;
+				}
+			} catch (java.io.IOException e) {
+				Object[] messageArguments = new Object[1];
+				messageArguments[0] = e.getMessage();
+				throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(), "io_exception",
+						messageArguments);
+			}
+			addParamValue(parameterIndex, new String(value));
+			break;
+		}
+	}
+
+	/**
+	 * Sets the designated parameter to the given <tt>Clob</tt> object. The
+	 * driver converts this to an SQL <tt>CLOB</tt> value when it sends it to
+	 * the database.
+	 * 
+	 * @param parameterIndex
+	 *            the first parameter is 1, the second is 2, ...
+	 * @param x
+	 *            a <tt>Clob</tt> object that maps an SQL <tt>CLOB</tt>
+	 * 
+	 * @throws SQLException
+	 *             invalid data type for column, or restricted data type.
+	 */
+	public void setClob(int parameterIndex, Clob x) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "setClob", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("setClob");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		int dataType;
+		long dataLocator;
+
+		validateSetInvocation(parameterIndex);
+		dataType = inputDesc_[parameterIndex - 1].dataType_;
+		switch (dataType) {
+		
+			
+		case Types.DECIMAL:
+		case Types.DOUBLE:
+		case Types.FLOAT:
+		case Types.NUMERIC:
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(),
+					"invalid_datatype_for_column", null);
+		default:
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(), "restricted_data_type",
+					null);
+		}
+	}
+
+	public void setDate(int parameterIndex, Date x) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "setDate", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("setDate");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		int dataType;
+		Timestamp t1;
+
+		validateSetInvocation(parameterIndex);
+		dataType = inputDesc_[parameterIndex - 1].dataType_;
+		if (dataType != Types.CHAR && dataType != Types.VARCHAR && dataType != Types.LONGVARCHAR
+				&& dataType != Types.DATE && dataType != Types.TIMESTAMP) {
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(), "restricted_data_type",
+					null);
+		}
+		if (x != null) {
+			if (dataType == Types.TIMESTAMP) {
+				t1 = new Timestamp(x.getTime());
+				addParamValue(parameterIndex, t1.toString());
+			} else {
+				addParamValue(parameterIndex, x.toString());
+			}
+		} else {
+			addParamValue(parameterIndex, null);
+		}
+	}
+
+	public void setDate(int parameterIndex, Date x, Calendar cal) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x, cal);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "setDate", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x, cal);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("setDate");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		int dataType;
+		long dateValue;
+		Date adjustedDate;
+		Timestamp t1;
+
+		validateSetInvocation(parameterIndex);
+		dataType = inputDesc_[parameterIndex - 1].dataType_;
+		if (dataType != Types.CHAR && dataType != Types.VARCHAR && dataType != Types.LONGVARCHAR
+				&& dataType != Types.DATE && dataType != Types.TIME && dataType != Types.TIMESTAMP) {
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(), "restricted_data_type",
+					null);
+		}
+		// Ignore the cal, since SQL would expect it to store it in the local
+		// time zone
+		if (x != null) {
+			if (dataType == Types.TIMESTAMP) {
+				t1 = new Timestamp(x.getTime());
+				addParamValue(parameterIndex, t1.toString());
+			} else {
+				addParamValue(parameterIndex, x.toString());
+			}
+		} else {
+			addParamValue(parameterIndex, null);
+
+		}
+	}
+
+	public void setDouble(int parameterIndex, double x) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "setDouble", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("setDouble");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		validateSetInvocation(parameterIndex);
+		inputDesc_[parameterIndex - 1].checkValidNumericConversion(connection_.getLocale());
+		addParamValue(parameterIndex, Double.toString(x));
+		inputDesc_[parameterIndex - 1].isValueSet_ = true;
+	}
+
+	public void setFloat(int parameterIndex, float x) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "setFloat", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("setFloat");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		validateSetInvocation(parameterIndex);
+		inputDesc_[parameterIndex - 1].checkValidNumericConversion(connection_.getLocale());
+		addParamValue(parameterIndex, Float.toString(x));
+	}
+
+	public void setInt(int parameterIndex, int x) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "setInt", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("setInt");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		validateSetInvocation(parameterIndex);
+		inputDesc_[parameterIndex - 1].checkValidNumericConversion(connection_.getLocale());
+		addParamValue(parameterIndex, Integer.toString(x));
+	}
+
+	public void setLong(int parameterIndex, long x) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "setLong", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("setLong");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		validateSetInvocation(parameterIndex);
+		inputDesc_[parameterIndex - 1].checkValidNumericConversion(connection_.getLocale());
+		Utility.checkLongBoundary(connection_.getLocale(), BigDecimal.valueOf(x));
+		addParamValue(parameterIndex, Long.toString(x));
+	}
+
+	public void setNull(int parameterIndex, int sqlType) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, sqlType);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "setNull", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, sqlType);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("setNull");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		validateSetInvocation(parameterIndex);
+		addParamValue(parameterIndex, null);
+	}
+
+	public void setNull(int paramIndex, int sqlType, String typeName) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, paramIndex, sqlType, typeName);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "setNull", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, paramIndex, sqlType, typeName);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("setNull");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		setNull(paramIndex, sqlType);
+	}
+
+	public void setObject(int parameterIndex, Object x) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "setObject", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("setObject");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		if (x == null) {
+			setNull(parameterIndex, Types.NULL);
+		} else if (x instanceof BigDecimal) {
+			setBigDecimal(parameterIndex, (BigDecimal) x);
+		} else if (x instanceof java.sql.Date) {
+			setDate(parameterIndex, (Date) x);
+		} else if (x instanceof java.sql.Time) {
+			setTime(parameterIndex, (Time) x);
+		} else if (x instanceof java.sql.Timestamp) {
+			setTimestamp(parameterIndex, (Timestamp) x);
+		} else if (x instanceof Double) {
+			setDouble(parameterIndex, ((Double) x).doubleValue());
+		} else if (x instanceof Float) {
+			setFloat(parameterIndex, ((Float) x).floatValue());
+		} else if (x instanceof Long) {
+			setLong(parameterIndex, ((Long) x).longValue());
+		} else if (x instanceof Integer) {
+			setInt(parameterIndex, ((Integer) x).intValue());
+		} else if (x instanceof Short) {
+			setShort(parameterIndex, ((Short) x).shortValue());
+		} else if (x instanceof Byte) {
+			setByte(parameterIndex, ((Byte) x).byteValue());
+		} else if (x instanceof Boolean) {
+			setBoolean(parameterIndex, ((Boolean) x).booleanValue());
+		} else if (x instanceof String) {
+			setString(parameterIndex, x.toString());
+		} else if (x instanceof byte[]) {
+			setBytes(parameterIndex, (byte[]) x);
+		} else if (x instanceof Clob) {
+			setClob(parameterIndex, (Clob) x);
+		} else if (x instanceof Blob) {
+			setBlob(parameterIndex, (Blob) x);
+			/*
+			 * else if (x instanceof DataWrapper) {
+			 * validateSetInvocation(parameterIndex); setObject(parameterIndex,
+			 * x, inputDesc_[parameterIndex - 1].dataType_); }
+			 */
+		} else if (x instanceof BigInteger) {
+			setBigDecimal(parameterIndex, new BigDecimal((BigInteger) x));
+		} else {
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(),
+					"object_type_not_supported", null);
+		}
+	}
+
+	public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x, targetSqlType);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "setObject", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x, targetSqlType);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("setObject");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		setObject(parameterIndex, x, targetSqlType, -1);
+	}
+
+	public void setObject(int parameterIndex, Object x, int targetSqlType, int scale) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x, targetSqlType, scale);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "setObject", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x, targetSqlType, scale);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("setObject");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		BigDecimal tmpbd;
+		int precision;
+		Locale locale = connection_.getLocale();
+
+		if (x == null) {
+			setNull(parameterIndex, Types.NULL);
+		} else {
+			switch (targetSqlType) {
+			case Types.CHAR:
+			case Types.VARCHAR:
+			case Types.LONGVARCHAR:
+                        case Types.BLOB:
+                        case Types.CLOB:
+				setString(parameterIndex, x.toString());
+				break;
+			case Types.VARBINARY:
+			case Types.BINARY:
+			case Types.LONGVARBINARY:
+				setBytes(parameterIndex, (byte[]) x);
+				break;
+			case Types.TIMESTAMP:
+				if (x instanceof Timestamp) {
+					setTimestamp(parameterIndex, (Timestamp) x);
+				} else if (x instanceof Date) {
+					setTimestamp(parameterIndex, Timestamp.valueOf(x.toString() + " 00:00:00.0"));
+				} else {
+					setString(parameterIndex, x.toString());
+				}
+				break;
+			case Types.TIME:
+				if (x instanceof Time) {
+					setTime(parameterIndex, (Time) x);
+				} else if (x instanceof Date) {
+					setTime(parameterIndex, new Time(((Date) x).getTime()));
+				} else if (x instanceof Timestamp) {
+					setTime(parameterIndex, new Time(((Timestamp) x).getTime()));
+				} else {
+					setString(parameterIndex, x.toString());
+				}
+				break;
+			case Types.DATE:
+				try {
+					if (x instanceof Date) {
+						setDate(parameterIndex, (Date) x);
+					} else if (x instanceof Time) {
+						setDate(parameterIndex, new Date(((Time) x).getTime()));
+					} else if (x instanceof Timestamp) {
+						setDate(parameterIndex, new Date(((Timestamp) x).getTime()));
+					} else {
+						setDate(parameterIndex, Date.valueOf(x.toString()));
+					}
+				} catch (IllegalArgumentException iex) {
+					throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(),
+							"invalid_parameter_value", x.toString());
+				}
+				break;
+			case Types.BOOLEAN:
+				setBoolean(parameterIndex, (Boolean.valueOf(x.toString())).booleanValue());
+				break;
+			case Types.SMALLINT:
+				tmpbd = Utility.getBigDecimalValue(locale, x);
+				Utility.checkShortBoundary(locale, tmpbd);
+				//Utility.checkLongTruncation(parameterIndex, tmpbd);
+				setShort(parameterIndex, tmpbd.shortValue());
+				break;
+			case Types.INTEGER:
+				tmpbd = Utility.getBigDecimalValue(locale, x);
+				//Utility.checkLongTruncation(parameterIndex, tmpbd);
+				//Utility.checkIntegerBoundary(locale, tmpbd);
+				setInt(parameterIndex, tmpbd.intValue());
+				break;
+			case Types.BIGINT:
+				tmpbd = Utility.getBigDecimalValue(locale, x);
+				Utility.checkLongBoundary(locale, tmpbd);
+				//Utility.checkLongTruncation(parameterIndex, tmpbd);
+				setLong(parameterIndex, tmpbd.longValue());
+				break;
+			case Types.DECIMAL:
+				// precision = getPrecision(parameterIndex - 1);
+				tmpbd = Utility.getBigDecimalValue(locale, x);
+				tmpbd = Utility.setScale(tmpbd, scale, BigDecimal.ROUND_HALF_EVEN);
+				// Utility.checkDecimalBoundary(locale, tmpbd, precision);
+				setBigDecimal(parameterIndex, tmpbd);
+				break;
+			case Types.NUMERIC:
+				// precision = getPrecision(parameterIndex - 1);
+				tmpbd = Utility.getBigDecimalValue(locale, x);
+				tmpbd = Utility.setScale(tmpbd, scale, BigDecimal.ROUND_HALF_EVEN);
+				// Utility.checkDecimalBoundary(locale, tmpbd, precision);
+				setBigDecimal(parameterIndex, tmpbd);
+				break;
+			case Types.TINYINT:
+				tmpbd = Utility.getBigDecimalValue(locale, x);
+				tmpbd = Utility.setScale(tmpbd, scale, roundingMode_);
+				Utility.checkTinyintBoundary(locale, tmpbd);
+				setShort(parameterIndex, tmpbd.shortValue());
+				break;
+			case Types.FLOAT:
+				tmpbd = Utility.getBigDecimalValue(locale, x);
+				Utility.checkFloatBoundary(locale, tmpbd);
+				setDouble(parameterIndex, tmpbd.doubleValue());
+				break;
+			case Types.DOUBLE:
+				tmpbd = Utility.getBigDecimalValue(locale, x);
+				Utility.checkDoubleBoundary(locale, tmpbd);
+				setDouble(parameterIndex, tmpbd.doubleValue());
+				break;
+			case Types.REAL:
+				tmpbd = Utility.getBigDecimalValue(locale, x);
+				setFloat(parameterIndex, tmpbd.floatValue());
+				break;
+			case Types.OTHER:
+				if (inputDesc_[parameterIndex].fsDataType_ == InterfaceResultSet.SQLTYPECODE_INTERVAL) {
+					if (x instanceof byte[]) {
+						addParamValue(parameterIndex, x);
+					} else if (x instanceof String) {
+						addParamValue(parameterIndex, x);
+					} else {
+						throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(),
+								"conversion_not_allowed", null);
+					}
+					break;
+				}
+			case Types.ARRAY:
+			case Types.BIT:
+			case Types.DATALINK:
+			case Types.DISTINCT:
+			case Types.JAVA_OBJECT:
+			case Types.STRUCT:
+			default:
+				throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(),
+						"object_type_not_supported", null);
+			}
+		}
+	}
+
+	// JDK 1.2
+	public void setRef(int i, Ref x) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, i, x);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "setRef", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, i, x);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("setRef");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		validateSetInvocation(i);
+		HPT4Messages.throwUnsupportedFeatureException(connection_.props_, connection_.getLocale(), "setRef()");
+	}
+
+	public void setShort(int parameterIndex, short x) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "setShort", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("setShort");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		validateSetInvocation(parameterIndex);
+		inputDesc_[parameterIndex - 1].checkValidNumericConversion(connection_.getLocale());
+		addParamValue(parameterIndex, Short.toString(x));
+	}
+
+	public void setString(int parameterIndex, String x) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "setString", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("setString");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		validateSetInvocation(parameterIndex);
+		int dataType = inputDesc_[parameterIndex - 1].dataType_;
+
+		switch (dataType) {
+		case Types.CHAR:
+		case Types.VARCHAR:
+		case Types.LONGVARCHAR:
+		case Types.DATE:
+		case Types.TIME:
+		case Types.TIMESTAMP:
+		case Types.OTHER: // This type maps to the Database 
+			// INTERVAL
+			addParamValue(parameterIndex, x);
+			break;
+			
+			
+		case Types.ARRAY:
+		case Types.BINARY:
+		case Types.BIT:
+		case Types.DATALINK:
+		case Types.JAVA_OBJECT:
+		case Types.REF:
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(),
+					"datatype_not_supported", null);
+		case Types.BIGINT:
+		case Types.INTEGER:
+		case Types.SMALLINT:
+		case Types.TINYINT:
+		case Types.DECIMAL:
+		case Types.NUMERIC:
+			if (x != null) {
+				x = x.trim(); // SQLJ is using numeric string with
+				// leading/trailing whitespace
+			}
+			setObject(parameterIndex, x, dataType);
+			break;
+		case Types.BLOB:
+		case Types.BOOLEAN:
+		case Types.DOUBLE:
+		case Types.FLOAT:
+		case Types.LONGVARBINARY:
+		case Types.NULL:
+		case Types.REAL:
+		case Types.VARBINARY:
+			setObject(parameterIndex, x, dataType);
+			break;
+		default:
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(),
+					"fetch_output_inconsistent", null);
+		}
+
+	}
+
+	public void setTime(int parameterIndex, Time x) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "setTime", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("setTime");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		int dataType;
+		Timestamp t1;
+
+		validateSetInvocation(parameterIndex);
+		dataType = inputDesc_[parameterIndex - 1].dataType_;
+		if (dataType != Types.CHAR && dataType != Types.VARCHAR && dataType != Types.LONGVARCHAR
+				&& dataType != Types.TIME && dataType != Types.TIMESTAMP) {
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(), "restricted_data_type",
+					null);
+		}
+		if (x != null) {
+			if (dataType == Types.TIMESTAMP) {
+				t1 = new Timestamp(x.getTime());
+				addParamValue(parameterIndex, t1.toString());
+			} else {
+				addParamValue(parameterIndex, x.toString());
+			}
+		} else {
+			addParamValue(parameterIndex, null);
+		}
+	}
+
+	public void setTime(int parameterIndex, Time x, Calendar cal) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x, cal);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "setTime", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x, cal);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("setTime");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		int dataType;
+		long timeValue;
+		Time adjustedTime;
+		Timestamp t1;
+
+		validateSetInvocation(parameterIndex);
+		dataType = inputDesc_[parameterIndex - 1].dataType_;
+		if (dataType != Types.CHAR && dataType != Types.VARCHAR && dataType != Types.LONGVARCHAR
+				&& dataType != Types.TIME && dataType != Types.TIMESTAMP) {
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(), "restricted_data_type",
+					null);
+		}
+		// Ignore the cal, since SQL would expect it to store it in the local
+		// time zone
+		if (x != null) {
+			if (dataType == Types.TIMESTAMP) {
+				t1 = new Timestamp(x.getTime());
+				addParamValue(parameterIndex, t1.toString());
+			} else {
+				addParamValue(parameterIndex, x.toString());
+			}
+		} else {
+			addParamValue(parameterIndex, null);
+		}
+	}
+
+	public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "setTimestamp", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("setTimestamp");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		int dataType;
+		Date d1;
+		Time t1;
+
+		validateSetInvocation(parameterIndex);
+		dataType = inputDesc_[parameterIndex - 1].dataType_;
+		if (dataType != Types.CHAR && dataType != Types.VARCHAR && dataType != Types.LONGVARCHAR
+				&& dataType != Types.DATE && dataType != Types.TIME && dataType != Types.TIMESTAMP) {
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(), "restricted_data_type",
+					null);
+		}
+		if (x != null) {
+			switch (dataType) {
+			case Types.DATE:
+				d1 = new Date(x.getTime());
+				addParamValue(parameterIndex, d1.toString());
+				break;
+			case Types.TIME:
+				t1 = new Time(x.getTime());
+				addParamValue(parameterIndex, t1.toString());
+				break;
+			default:
+				addParamValue(parameterIndex, x.toString());
+				break;
+			}
+		} else {
+			addParamValue(parameterIndex, null);
+		}
+	}
+
+	public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x, cal);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "setTimestamp", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x, cal);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("setTimestamp");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		int dataType;
+		long timeValue;
+		Timestamp adjustedTime;
+		Date d1;
+		Time t1;
+
+		validateSetInvocation(parameterIndex);
+		dataType = inputDesc_[parameterIndex - 1].dataType_;
+		if (dataType != Types.CHAR && dataType != Types.VARCHAR && dataType != Types.LONGVARCHAR
+				&& dataType != Types.DATE && dataType != Types.TIME && dataType != Types.TIMESTAMP) {
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(), "restricted_data_type",
+					null);
+		}
+		// Ignore the cal, since SQL would expect it to store it in the local
+		// time zone
+		if (x != null) {
+			switch (dataType) {
+			case Types.DATE:
+				d1 = new Date(x.getTime());
+				addParamValue(parameterIndex, d1.toString());
+				break;
+			case Types.TIME:
+				t1 = new Time(x.getTime());
+				addParamValue(parameterIndex, t1.toString());
+				break;
+			default:
+				addParamValue(parameterIndex, x.toString());
+				break;
+			}
+		} else {
+			addParamValue(parameterIndex, null);
+		}
+	}
+
+	public void setUnicodeStream(int parameterIndex, InputStream x, int length) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x, length);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "setUnicodeStream", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x, length);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("setUnicodeStream");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		byte[] buffer = new byte[length]; // length = number of bytes in
+		// stream
+		validateSetInvocation(parameterIndex);
+		String s;
+
+		if (x == null) {
+			addParamValue(parameterIndex, null);
+		} else {
+			int dataType = inputDesc_[parameterIndex - 1].dataType_;
+			switch (dataType) {
+			case Types.DECIMAL:
+			case Types.DOUBLE:
+			case Types.FLOAT:
+			case Types.NUMERIC:
+			case Types.SMALLINT:
+			case Types.INTEGER:
+			case Types.BIGINT:
+			case Types.TINYINT:
+				throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(),
+						"invalid_datatype_for_column", null);
+			default:
+				try {
+					x.read(buffer, 0, length);
+				} catch (java.io.IOException e) {
+					Object[] messageArguments = new Object[1];
+					messageArguments[0] = e.getMessage();
+					throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(), "io_exception",
+							messageArguments);
+				}
+				try {
+					s = new String(buffer, "UnicodeBig");
+					addParamValue(parameterIndex, s);
+				} catch (java.io.UnsupportedEncodingException e) {
+					Object[] messageArguments = new Object[1];
+					messageArguments[0] = e.getMessage();
+					throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(),
+							"unsupported_encoding", messageArguments);
+				}
+				break;
+			}
+		}
+	}
+
+	public void setURL(int parameterIndex, URL x) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "setURL", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("setURL");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		validateSetInvocation(parameterIndex);
+		HPT4Messages.throwUnsupportedFeatureException(connection_.props_, connection_.getLocale(), "setURL()");
+	} // end setURL
+
+	// -------------------------------------------------------------------------------------------
+	/**
+	 * This method will associate user defined data with the prepared statement.
+	 * The user defined data must be in SQL/MX rowwise rowset format.
+	 * 
+	 * @param numRows
+	 *            the number of rows contained in buffer
+	 * @param buffer
+	 *            a buffer containing the rows
+	 * 
+	 * @exception A
+	 *                SQLException is thrown
+	 */
+	public void setDataBuffer(int numRows, ByteBuffer buffer) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, numRows, buffer);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "setDataBuffer", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, numRows, buffer);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("setDataBuffer");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		usingRawRowset_ = true;
+		paramRowCount_ = numRows;
+		rowwiseRowsetBuffer_ = buffer;
+	} // end setDataBufferBuffer
+
+	// -------------------------------------------------------------------------------------------
+
+	// Other methods
+	protected void validateExecuteInvocation() throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINER) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+			connection_.props_.t4Logger_.logp(Level.FINER, "TrafT4PreparedStatement", "validateExecuteInvocation", "", p);
+		}
+		clearWarnings();
+		if (isClosed_) {
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(), "stmt_closed", null);
+		}
+		// connection_.getServerHandle().isConnectionOpen();
+		connection_.isConnectionOpen();
+		// close the previous resultset, if any
+		for (int i = 0; i < num_result_sets_; i++) {
+			if (resultSet_[i] != null) {
+				resultSet_[i].close();
+			}
+		}
+		if (paramRowCount_ > 0 && usingRawRowset_ == false) {
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(),
+					"function_sequence_error", null);
+		}
+
+		if (usingRawRowset_ == false)
+			checkIfAllParamsSet();
+
+	}
+
+	private void checkIfAllParamsSet() throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINER) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+			connection_.props_.t4Logger_.logp(Level.FINER, "TrafT4PreparedStatement", "checkIfAllParamsSet", "", p);
+		}
+		int paramNumber;
+
+		if (inputDesc_ == null) {
+			return;
+		}
+		for (paramNumber = 0; paramNumber < inputDesc_.length; paramNumber++) {
+			if (!inputDesc_[paramNumber].isValueSet_) {
+				Object[] messageArguments = new Object[2];
+				messageArguments[0] = new Integer(paramNumber + 1);
+				messageArguments[1] = new Integer(paramRowCount_ + 1);
+				throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(), "parameter_not_set",
+						messageArguments);
+			}
+		}
+	}
+
+	private void validateSetInvocation(int parameterIndex) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINER) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex);
+			connection_.props_.t4Logger_.logp(Level.FINER, "TrafT4PreparedStatement", "validateSetInvocation", "", p);
+		}
+		if (isClosed_) {
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(), "stmt_closed", null);
+		}
+		// connection_.getServerHandle().isConnectionOpen();
+		connection_.isConnectionOpen();
+		if (inputDesc_ == null) {
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(),
+					"invalid_parameter_index", null);
+		}
+		if (parameterIndex < 1 || parameterIndex > inputDesc_.length) {
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(),
+					"invalid_parameter_index", null);
+		}
+		if (inputDesc_[parameterIndex - 1].paramMode_ == DatabaseMetaData.procedureColumnOut) {
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(), "is_a_output_parameter",
+					null);
+		}
+	}
+
+	void addParamValue(int parameterIndex, Object x) {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINER) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, parameterIndex, x);
+			connection_.props_.t4Logger_.logp(Level.FINER, "TrafT4PreparedStatement", "addParamValue", "", p);
+		}
+
+		paramsValue_[parameterIndex - 1] = x;
+		inputDesc_[parameterIndex - 1].isValueSet_ = true;
+	}
+
+	Object[] getValueArray() {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINER) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+			connection_.props_.t4Logger_.logp(Level.FINER, "TrafT4PreparedStatement", "getValueArray", "", p);
+		}
+		Object[] valueArray;
+		int length;
+		int i;
+		int j;
+		int index;
+		Object[] rows;
+
+		if (paramRowCount_ > 0) {
+			valueArray = new Object[(paramRowCount_ + 1) * inputDesc_.length];
+			length = rowsValue_.size();
+			for (i = 0, index = 0; i < length; i++) {
+				rows = (Object[]) rowsValue_.get(i);
+				for (j = 0; j < rows.length; j++, index++) {
+					valueArray[index] = rows[j];
+				}
+			}
+		} else {
+			valueArray = paramsValue_;
+		}
+		return valueArray;
+	}
+
+	void logicalClose() throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINER) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_);
+			connection_.props_.t4Logger_.logp(Level.FINER, "TrafT4PreparedStatement", "logicalClose", "", p);
+		}
+		isClosed_ = true;
+		if (rowsValue_ != null) {
+			rowsValue_.clear();
+			
+		}
+		if (lobObjects_ != null) {
+			lobObjects_.clear();
+
+		}
+		paramRowCount_ = 0;
+		for (int i = 0; i < num_result_sets_; i++) {
+			if (resultSet_[i] != null) {
+				resultSet_[i].close();
+				// Clear the isValueSet_ flag in inputDesc_
+			}
+		}
+		result_set_offset = 0;
+		resultSet_[result_set_offset] = null;
+		if (inputDesc_ != null) {
+			for (int i = 0; i < inputDesc_.length; i++) {
+				inputDesc_[i].isValueSet_ = false;
+				paramsValue_[i] = null;
+			}
+		}
+		isAnyLob_ = false;
+		if (!connection_.closePreparedStatement(connection_, sql_, resultSetType_, resultSetConcurrency_,
+				resultSetHoldability_)) {
+			this.close(true); // if the statement is not in the cache
+			// hardclose it afterall
+		}
+
+	}
+
+	// ----------------------------------------------------------------------------------
+	// Method used by JNI Layer to update the results of Prepare
+	void setPrepareOutputs(HPT4Desc[] inputDesc, HPT4Desc[] outputDesc, int inputParamCount, int outputParamCount)
+			throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINER) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, inputDesc, outputDesc, inputParamCount,
+					outputParamCount);
+			connection_.props_.t4Logger_.logp(Level.FINER, "TrafT4PreparedStatement", "setPrepareOutputs", "", p);
+		}
+		inputDesc_ = inputDesc;
+		outputDesc_ = outputDesc;
+		paramRowCount_ = 0;
+
+		// Prepare updares inputDesc_ and outputDesc_
+		if (inputDesc_ != null) {
+			paramsValue_ = new Object[inputDesc_.length];
+		} else {
+			paramsValue_ = null;
+		}
+	} // end setPrepareOutputs
+
+	// ----------------------------------------------------------------------------------
+	void setPrepareOutputs2(HPT4Desc[] inputDesc, HPT4Desc[] outputDesc, int inputParamCount, int outputParamCount,
+			int inputParamsLength, int outputParamsLength, int inputDescLength, int outputDescLength)
+			throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINER) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, inputDesc, outputDesc, inputParamCount,
+					outputParamCount, inputParamsLength, outputParamsLength, inputDescLength, outputDescLength);
+			connection_.props_.t4Logger_.logp(Level.FINER, "TrafT4PreparedStatement", "setPrepareOutputs2", "", p);
+		}
+		inputParamCount_ = inputParamCount;
+		outputParamCount_ = outputParamCount;
+		inputParamsLength_ = inputParamsLength;
+		outputParamsLength_ = outputParamsLength;
+		inputDescLength_ = inputDescLength;
+		outputDescLength_ = outputDescLength;
+		setPrepareOutputs(inputDesc, outputDesc, inputParamCount, outputParamCount);
+	} // end setPrepareOutputs2
+
+	// ----------------------------------------------------------------------------------
+	// Method used by JNI layer to update the results of Execute
+	void setExecuteOutputs(int rowCount) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINER) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, rowCount);
+			connection_.props_.t4Logger_.logp(Level.FINER, "TrafT4PreparedStatement", "setExecuteOutputs", "", p);
+		}
+		batchRowCount_ = new int[1];
+		batchRowCount_[0] = rowCount;
+		num_result_sets_ = 1;
+		result_set_offset = 0;
+		if (outputDesc_ != null) {
+			resultSet_[result_set_offset] = new TrafT4ResultSet(this, outputDesc_);
+		} else {
+			resultSet_[result_set_offset] = null;
+		}
+	}
+
+	/*
+	 * //----------------------------------------------------------------------------------
+	 * void setExecuteSingletonOutputs(SQLValue_def[] sqlValue_def_array, short
+	 * rowsAffected) throws SQLException { batchRowCount_ = new int[1];
+	 * batchRowCount_[0] = rowsAffected; if (outputDesc_ != null) { resultSet_ =
+	 * new TrafT4ResultSet(this, outputDesc_); } else { resultSet_ = null; } if
+	 * (rowsAffected == 0) { resultSet_.setFetchOutputs(new Row[0], 0, true, 0); }
+	 * else { resultSet_.irs_.setSingletonFetchOutputs(resultSet_, rowsAffected,
+	 * true, 0, sqlValue_def_array); } }
+	 */
+
+	// ----------------------------------------------------------------------------------
+	// Method used by JNI layer to update the results of Execute
+	void setExecuteBatchOutputs(int[] rowCount) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINER) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, rowCount);
+			connection_.props_.t4Logger_.logp(Level.FINER, "TrafT4PreparedStatement", "setExecuteBatchOutputs", "", p);
+		}
+		num_result_sets_ = 1;
+		result_set_offset = 0;
+		if (outputDesc_ != null) {
+			resultSet_[result_set_offset] = new TrafT4ResultSet(this, outputDesc_);
+		} else {
+			resultSet_[result_set_offset] = null;
+		}
+		batchRowCount_ = rowCount;
+	}
+
+	void reuse(TrafT4Connection connection, int resultSetType, int resultSetConcurrency, int resultSetHoldability)
+			throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINER) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, connection, resultSetType,
+					resultSetConcurrency, resultSetHoldability);
+			connection_.props_.t4Logger_.logp(Level.FINER, "TrafT4PreparedStatement", "reuse", "", p);
+		}
+		if (resultSetType != ResultSet.TYPE_FORWARD_ONLY && resultSetType != ResultSet.TYPE_SCROLL_INSENSITIVE
+				&& resultSetType != ResultSet.TYPE_SCROLL_SENSITIVE) {
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(),
+					"invalid_resultset_type", null);
+		}
+		if (resultSetType == ResultSet.TYPE_SCROLL_SENSITIVE) {
+			resultSetType_ = ResultSet.TYPE_SCROLL_INSENSITIVE;
+			setSQLWarning(null, "scrollResultSetChanged", null);
+		} else {
+			resultSetType_ = resultSetType;
+		}
+		if (resultSetConcurrency != ResultSet.CONCUR_READ_ONLY && resultSetConcurrency != ResultSet.CONCUR_UPDATABLE) {
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(),
+					"invalid_resultset_concurrency", null);
+		}
+		resultSetConcurrency_ = resultSetConcurrency;
+		resultSetHoldability_ = resultSetHoldability;
+		queryTimeout_ = connection_.getServerHandle().getQueryTimeout();
+		fetchSize_ = TrafT4ResultSet.DEFAULT_FETCH_SIZE;
+		maxRows_ = 0;
+		fetchDirection_ = ResultSet.FETCH_FORWARD;
+		isClosed_ = false;
+	}
+
+	public void close(boolean hardClose) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINER) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, hardClose);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "close", "", p);
+		}
+
+		if (connection_._isClosed()) {
+			return;
+		}
+		try {
+			if (hardClose) {
+				ist_.close();
+			} else {
+				logicalClose();
+			}
+		} catch (SQLException e) {
+			performConnectionErrorChecks(e);
+			throw e;
+		} finally {
+			isClosed_ = true;
+			if (hardClose) {
+				connection_.removeElement(pRef_);
+			}
+		}
+
+	}
+
+
+	TrafT4PreparedStatement(TrafT4Connection connection, String sql, String stmtLabel) throws SQLException {
+		this(connection, sql, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, connection.holdability_,
+				stmtLabel);
+		connection.ic_.t4props_.setUseArrayBinding(false);
+		connection.ic_.t4props_.setBatchRecovery(false);
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, connection, sql);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "",
+					"Note, this call is before previous constructor call.", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, connection, sql);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+	}
+
+	// Constructors with access specifier as "default"
+	TrafT4PreparedStatement(TrafT4Connection connection, String sql) throws SQLException {
+		this(connection, sql, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, connection.holdability_);
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, connection, sql);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "",
+					"Note, this call is before previous constructor call.", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, connection, sql);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+	}
+
+	TrafT4PreparedStatement(TrafT4Connection connection, String sql, int resultSetType, int resultSetConcurrency)
+			throws SQLException {
+		this(connection, sql, resultSetType, resultSetConcurrency, connection.holdability_);
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, connection, sql, resultSetType,
+					resultSetConcurrency);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "",
+					"Note, this call is before previous constructor call.", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, connection, sql, resultSetType,
+					resultSetConcurrency);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+
+	}
+	TrafT4PreparedStatement(TrafT4Connection connection, String sql, int resultSetType, int resultSetConcurrency,
+			int resultSetHoldability, String stmtLabel) throws SQLException {
+		super(connection, resultSetType, resultSetConcurrency, resultSetHoldability, stmtLabel);
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, connection, sql, resultSetType,
+					resultSetConcurrency, resultSetHoldability);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "",
+					"Note, this call is before previous constructor call.", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, connection, sql, resultSetType,
+					resultSetConcurrency, resultSetHoldability);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		// connection_.getServerHandle().isConnectionOpen();
+		connection_.isConnectionOpen();
+		sqlStmtType_ = ist_.getSqlStmtType(sql);
+		if (sqlStmtType_ == TRANSPORT.TYPE_STATS) {
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(),
+					"infostats_invalid_error", null);
+		} else if (sqlStmtType_ == TRANSPORT.TYPE_CONFIG) {
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(),
+					"config_cmd_invalid_error", null);
+		}
+		ist_.setTransactionStatus(connection_, sql);
+		sql_ = sql;
+
+
+		// stmtLabel_ = generateStmtLabel();
+		stmtLabel_ = stmtLabel;
+		// System.out.println("TrafT4PreparedStatement stmtLabel_ " + stmtLabel_);
+
+		usingRawRowset_ = false;
+	}
+
+	TrafT4PreparedStatement(TrafT4Connection connection, String sql, int resultSetType, int resultSetConcurrency,
+			int resultSetHoldability) throws SQLException {
+		super(connection, resultSetType, resultSetConcurrency, resultSetHoldability);
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, connection, sql, resultSetType,
+					resultSetConcurrency, resultSetHoldability);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "",
+					"Note, this call is before previous constructor call.", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, connection, sql, resultSetType,
+					resultSetConcurrency, resultSetHoldability);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		// connection_.getServerHandle().isConnectionOpen();
+		connection_.isConnectionOpen();
+		sqlStmtType_ = ist_.getSqlStmtType(sql);
+		if (sqlStmtType_ == TRANSPORT.TYPE_STATS) {
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(),
+					"infostats_invalid_error", null);
+		} else if (sqlStmtType_ == TRANSPORT.TYPE_CONFIG) {
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(),
+					"config_cmd_invalid_error", null);
+		}
+		ist_.setTransactionStatus(connection_, sql);
+		sql_ = sql;
+
+
+		//stmtLabel_ = generateStmtLabel();
+
+		usingRawRowset_ = false;
+	}
+
+	TrafT4PreparedStatement(TrafT4Connection connection, String moduleName, int moduleVersion, long moduleTimestamp,
+			String stmtName, boolean isSelect, int holdability) {
+		if (connection.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection.props_, connection, moduleName, moduleVersion,
+					moduleTimestamp, stmtName, isSelect, holdability);
+			connection.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "", "", p);
+		}
+		try {
+			if (connection.props_.getLogWriter() != null) {
+				LogRecord lr = new LogRecord(Level.FINE, "");
+				Object p[] = T4LoggingUtilities.makeParams(connection.props_, connection, moduleName, moduleVersion,
+						moduleTimestamp, stmtName, isSelect, holdability);
+				lr.setParameters(p);
+				lr.setSourceClassName("TrafT4PreparedStatement");
+				lr.setSourceMethodName("");
+				T4LogFormatter lf = new T4LogFormatter();
+				String temp = lf.format(lr);
+				connection.props_.getLogWriter().println(temp);
+			}
+		} catch (SQLException se) {
+			// ignore
+		}
+		connection_ = connection;
+		moduleName_ = moduleName;
+		moduleVersion_ = moduleVersion;
+		moduleTimestamp_ = moduleTimestamp;
+		stmtLabel_ = stmtName;
+		sqlStmtType_ = (isSelect) ? TRANSPORT.TYPE_SELECT : TRANSPORT.TYPE_UNKNOWN;
+		usingRawRowset_ = false;
+
+		// Make Sure you initialize the other fields to the right value
+		fetchSize_ = TrafT4ResultSet.DEFAULT_FETCH_SIZE;
+		maxRows_ = 0;
+		fetchDirection_ = ResultSet.FETCH_FORWARD;
+		queryTimeout_ = connection_.getServerHandle().getQueryTimeout();
+		resultSetType_ = ResultSet.TYPE_FORWARD_ONLY;
+		resultSetHoldability_ = holdability;
+		usingRawRowset_ = false;
+	}
+
+	// Interface methods
+	public void prepare(String sql, int queryTimeout, int holdability) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, sql, queryTimeout, holdability);
+			connection_.props_.t4Logger_.logp(Level.FINE, "TrafT4PreparedStatement", "prepare", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, sql, queryTimeout, holdability);
+			lr.setParameters(p);
+			lr.setSourceClassName("TrafT4PreparedStatement");
+			lr.setSourceMethodName("prepare");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+		try {
+			super.ist_.prepare(sql, queryTimeout, this);
+		} catch (SQLException e) {
+			performConnectionErrorChecks(e);
+			throw e;
+		}
+	};
+
+	public void setFetchSize(int rows) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINE) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, rows);
+			connection_.props_.t4Logger_.logp(Level.FINE, "SQLMXPreparedStatement", "setFetchSize", "", p);
+		}
+		if (connection_.props_.getLogWriter() != null) {
+			LogRecord lr = new LogRecord(Level.FINE, "");
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, rows);
+			lr.setParameters(p);
+			lr.setSourceClassName("SQLMXPreparedStatement");
+			lr.setSourceMethodName("setFetchSize");
+			T4LogFormatter lf = new T4LogFormatter();
+			String temp = lf.format(lr);
+			connection_.props_.getLogWriter().println(temp);
+		}
+
+		if (rows < 0) {
+			throw HPT4Messages.createSQLException(connection_.props_, connection_.getLocale(),
+					"invalid_fetchSize_value", null);
+		}
+		if (rows > 0) {
+			fetchSize_ = rows;
+		}
+		// If the value specified is zero, then the hint is ignored.
+	}
+
+	private void execute(int paramRowCount, int paramCount, Object[] paramValues, int queryTimeout, boolean isAnyLob
+	) throws SQLException {
+		if (connection_.props_.t4Logger_.isLoggable(Level.FINER) == true) {
+			Object p[] = T4LoggingUtilities.makeParams(connection_.props_, paramRowCount, paramCount, paramValues,
+					queryTimeout, isAnyLob);
+			connection_.props_.t4Logger_.logp(Level.FINER, "TrafT4PreparedStatement", "execute", "", p);
+		}
+		try {
+			ist_.execute(TRANSPORT.SRVR_API_SQLEXECUTE2, paramRowCount, paramCount, paramValues, queryTimeout, null,
+					this);
+		} catch (SQLException e) {
+			performConnectionErrorChecks(e);
+			throw e;
+		}
+	};
+
+	/*
+	 * protected void setSingleton(boolean value) { singleton_ = value; }
+	 * protected boolean getSingleton() { return singleton_; }
+	 */
+
+	/**
+	 * Use this method to retrieve the 

<TRUNCATED>