You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@trafodion.apache.org by db...@apache.org on 2016/05/02 18:12:22 UTC
[43/60] incubator-trafodion git commit: Merge branch 'master' of
github.com:apache/incubator-trafodion into wrkbrnch
http://git-wip-us.apache.org/repos/asf/incubator-trafodion/blob/a0f21cde/core/conn/jdbcT4/src/main/java/org/trafodion/jdbc/t4/TrafT4PreparedStatement.java
----------------------------------------------------------------------
diff --cc core/conn/jdbcT4/src/main/java/org/trafodion/jdbc/t4/TrafT4PreparedStatement.java
index 489904f,0000000..0d4fe28
mode 100644,000000..100644
--- 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
@@@ -1,2558 -1,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); }
++ * (rowsAffected == 0) { resultSet_.setFetchOutputs(new ObjectRow[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, queryTimeou
<TRUNCATED>