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 2017/04/18 23:52:58 UTC
[38/44] incubator-trafodion git commit: Refact package name
http://git-wip-us.apache.org/repos/asf/incubator-trafodion/blob/51a83dc2/core/conn/jdbc_type2/src/main/java/org/apache/trafodion/jdbc/t2/SQLMXCallableStatement.java
----------------------------------------------------------------------
diff --git a/core/conn/jdbc_type2/src/main/java/org/apache/trafodion/jdbc/t2/SQLMXCallableStatement.java b/core/conn/jdbc_type2/src/main/java/org/apache/trafodion/jdbc/t2/SQLMXCallableStatement.java
new file mode 100644
index 0000000..49ae072
--- /dev/null
+++ b/core/conn/jdbc_type2/src/main/java/org/apache/trafodion/jdbc/t2/SQLMXCallableStatement.java
@@ -0,0 +1,2181 @@
+// @@@ START COPYRIGHT @@@
+//
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+//
+// @@@ END COPYRIGHT @@@
+
+/* -*-java-*-
+ * Filename : SQLMXCallableStatement.java
+ * Description :
+ */
+
+package org.apache.trafodion.jdbc.t2;
+
+import java.sql.*;
+import java.math.BigDecimal;
+import java.util.Calendar;
+import java.util.Map;
+import java.net.URL;
+import java.io.InputStream;
+import java.io.Reader;
+
+public class SQLMXCallableStatement extends SQLMXPreparedStatement implements
+java.sql.CallableStatement {
+public Array getArray(int parameterIndex) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getArray_I].methodEntry();
+ try {
+ clearWarnings();
+ Messages.throwUnsupportedFeatureException(connection_.locale_,
+ "getArray()");
+ return null;
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getArray_I].methodExit();
+ }
+ }
+
+public Array getArray(String parameterName) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getArray_L].methodEntry();
+ try {
+ int parameterIndex = validateGetInvocation(parameterName);
+ return getArray(parameterIndex);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getArray_L].methodExit();
+ }
+ }
+
+public BigDecimal getBigDecimal(int parameterIndex) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getBigDecimal_I].methodEntry();
+ try {
+ BigDecimal retValue;
+ String data;
+
+ validateGetInvocation(parameterIndex);
+ inputDesc_[parameterIndex - 1]
+ .checkValidNumericConversion(connection_.locale_);
+ // String returned may not be numeric in case of SQL_CHAR,
+ // SQL_VARCHAR and SQL_LONGVARCHAR
+ // fields. Hoping that java might throw invalid value exception
+ data = getString(parameterIndex);
+ if (data == null) {
+ wasNull_ = true;
+ return null;
+ } else {
+ wasNull_ = false;
+ try {
+ retValue = new BigDecimal(data);
+ } catch (NumberFormatException e) {
+ throw Messages.createSQLException(connection_.locale_,
+ "invalid_cast_specification", null);
+ }
+ return retValue;
+ }
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getBigDecimal_I].methodExit();
+ }
+ }
+
+ @Deprecated
+public BigDecimal getBigDecimal(int parameterIndex, int scale)
+ throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getBigDecimal_II].methodEntry();
+ try {
+ BigDecimal retValue;
+
+ retValue = getBigDecimal(parameterIndex);
+ if (retValue != null)
+ return retValue.setScale(scale);
+ else
+ return null;
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getBigDecimal_II].methodExit();
+ }
+ }
+
+public BigDecimal getBigDecimal(String parameterName) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getBigDecimal_L].methodEntry();
+ try {
+ int parameterIndex = validateGetInvocation(parameterName);
+ return getBigDecimal(parameterIndex);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getBigDecimal_L].methodExit();
+ }
+ }
+
+ @Deprecated
+public BigDecimal getBigDecimal(String parameterName, int scale)
+ throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getBigDecimal_LI].methodEntry();
+ try {
+ int parameterIndex = validateGetInvocation(parameterName);
+ return getBigDecimal(parameterIndex, scale);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getBigDecimal_LI].methodExit();
+ }
+ }
+
+public Blob getBlob(int parameterIndex) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getBlob_I].methodEntry();
+ try {
+ Messages.throwUnsupportedFeatureException(connection_.locale_,
+ "getBlob()");
+ return null;
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getBlob_I].methodExit();
+ }
+ }
+
+public Blob getBlob(String parameterName) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getBlob_L].methodEntry();
+ try {
+ int parameterIndex = validateGetInvocation(parameterName);
+ return getBlob(parameterIndex);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getBlob_L].methodExit();
+ }
+ }
+
+public boolean getBoolean(int parameterIndex) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getBoolean_I].methodEntry();
+ try {
+ String data;
+
+ validateGetInvocation(parameterIndex);
+ inputDesc_[parameterIndex - 1]
+ .checkValidNumericConversion(connection_.locale_);
+ data = getString(parameterIndex);
+ if (data != null) {
+ wasNull_ = false;
+ return (!data.equals("0"));
+ } else {
+ wasNull_ = true;
+ return false;
+ }
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getBoolean_I].methodExit();
+ }
+ }
+
+public boolean getBoolean(String parameterName) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getBoolean_L].methodEntry();
+ try {
+ int parameterIndex = validateGetInvocation(parameterName);
+ return getBoolean(parameterIndex);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getBoolean_L].methodExit();
+ }
+ }
+
+public byte getByte(int parameterIndex) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getByte_I].methodEntry();
+ try {
+ String data;
+
+ validateGetInvocation(parameterIndex);
+ inputDesc_[parameterIndex - 1]
+ .checkValidNumericConversion(connection_.locale_);
+ data = getString(parameterIndex);
+ if (data != null) {
+ wasNull_ = false;
+ return Byte.parseByte(data);
+ } else {
+ wasNull_ = true;
+ return 0;
+ }
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getByte_I].methodExit();
+ }
+ }
+
+public byte getByte(String parameterName) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getByte_L].methodEntry();
+ try {
+ int parameterIndex = validateGetInvocation(parameterName);
+ return getByte(parameterIndex);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getByte_L].methodExit();
+ }
+ }
+
+public byte[] getBytes(int parameterIndex) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getBytes_I].methodEntry();
+ try {
+ validateGetInvocation(parameterIndex);
+ // BINARY, VARBINARY, LONGVARBINARY not supported
+ throw Messages.createSQLException(connection_.locale_,
+ "datatype_not_supported", null);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getBytes_I].methodExit();
+ }
+
+ }
+
+public byte[] getBytes(String parameterName) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getBytes_L].methodEntry();
+ try {
+ int parameterIndex = validateGetInvocation(parameterName);
+ return getBytes(parameterIndex);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getBytes_L].methodExit();
+ }
+ }
+
+public Clob getClob(int parameterIndex) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getClob_I].methodEntry();
+ try {
+ Messages.throwUnsupportedFeatureException(connection_.locale_,
+ "getClob()");
+ return null;
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getClob_I].methodExit();
+ }
+ }
+
+public Clob getClob(String parameterName) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getClob_L].methodEntry();
+ try {
+ int parameterIndex = validateGetInvocation(parameterName);
+ return getClob(parameterIndex);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getClob_L].methodExit();
+ }
+ }
+
+public Date getDate(int parameterIndex) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getDate_I].methodEntry();
+ try {
+ int dataType;
+ String dateStr;
+ Date retValue;
+
+ validateGetInvocation(parameterIndex);
+ dataType = inputDesc_[parameterIndex - 1].dataType_;
+ if (dataType != Types.CHAR && dataType != Types.VARCHAR
+ && dataType != Types.LONGVARCHAR && dataType != Types.DATE
+ && dataType != Types.TIMESTAMP)
+ throw Messages.createSQLException(connection_.locale_,
+ "restricted_data_type", null);
+ dateStr = getString(parameterIndex);
+ if (dateStr != null) {
+ wasNull_ = false;
+ try {
+ retValue = Date.valueOf(dateStr);
+ } catch (IllegalArgumentException e) {
+ throw Messages.createSQLException(connection_.locale_,
+ "invalid_cast_specification", null);
+ }
+ return retValue;
+ } else {
+ wasNull_ = true;
+ return null;
+ }
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getDate_I].methodExit();
+ }
+ }
+
+public Date getDate(int parameterIndex, Calendar cal) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getDate_IL].methodEntry();
+ try {
+ Date sqlDate;
+ java.util.Date d;
+
+ sqlDate = getDate(parameterIndex);
+ if (sqlDate != null) {
+ if (cal != null) {
+ cal.setTime(sqlDate);
+ d = cal.getTime();
+ sqlDate = new Date(d.getTime());
+ }
+ return sqlDate;
+ } else
+ return (sqlDate);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getDate_IL].methodExit();
+ }
+ }
+
+public Date getDate(String parameterName) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getDate_L].methodEntry();
+ try {
+ int parameterIndex = validateGetInvocation(parameterName);
+ return getDate(parameterIndex);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getDate_L].methodExit();
+ }
+ }
+
+public Date getDate(String parameterName, Calendar cal) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getDate_LL].methodEntry();
+ try {
+ int parameterIndex = validateGetInvocation(parameterName);
+ return getDate(parameterIndex, cal);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getDate_LL].methodExit();
+ }
+ }
+
+ //**************************************************************************
+ // **
+ // *
+ // * METHOD: getDouble
+ // *
+ // * DESCRIPTION: This routine is called directly or by getDouble(string) to
+ // return
+ // * the double floating point value from the resultset. All of the
+ // * result set data values are stored as strings, and have to be converted
+ // * from a string to a double floating point value.
+ // *
+ // * INPUT: columIndex
+ // *
+ // * RETURN: double - a double floating point value, which is the result of
+ // the
+ // * string to floating point conversion.
+ // *
+ //**************************************************************************
+ // **
+public double getDouble(int parameterIndex) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getDouble_I].methodEntry();
+ try {
+ String data;
+
+ validateGetInvocation(parameterIndex);
+ inputDesc_[parameterIndex - 1]
+ .checkValidNumericConversion(connection_.locale_);
+ data = getString(parameterIndex);
+ if (data != null) {
+ try {
+ wasNull_ = false;
+ return Double.parseDouble(data);
+ } catch (NumberFormatException e1) {
+ throw Messages.createSQLException(connection_.locale_,
+ "invalid_cast_specification", null);
+ }
+ } else {
+ wasNull_ = true;
+ return 0;
+ }
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getDouble_I].methodExit();
+ }
+ }
+
+public double getDouble(String parameterName) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getDouble_L].methodEntry();
+ try {
+ int parameterIndex = validateGetInvocation(parameterName);
+ return getDouble(parameterIndex);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getDouble_L].methodExit();
+ }
+ }
+
+ //**************************************************************************
+ // **
+ // *
+ // * METHOD: getFloat
+ // *
+ // * DESCRIPTION: This routine is called directly or by getFloat(string) to
+ // * return the floating point value from the resultset. All of the
+ // * result set data values are stored as strings, and have to be
+ // * converted from a string to a floating point value.
+ // *
+ // * INPUT: columIndex
+ // *
+ // * RETURN: float - a 32-bit floating point value, which is the result of
+ // the
+ // * string to floating point conversion.
+ // *
+ //**************************************************************************
+ // **
+public float getFloat(int parameterIndex) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getFloat_I].methodEntry();
+ try {
+ String data;
+
+ validateGetInvocation(parameterIndex);
+ inputDesc_[parameterIndex - 1]
+ .checkValidNumericConversion(connection_.locale_);
+ data = getString(parameterIndex);
+ if (data != null) {
+ try {
+ wasNull_ = false;
+ return Float.parseFloat(data);
+ } catch (NumberFormatException e1) {
+ throw Messages.createSQLException(connection_.locale_,
+ "invalid_cast_specification", null);
+ }
+ } else {
+ wasNull_ = true;
+ return 0;
+ }
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getFloat_I].methodExit();
+ }
+ }
+
+public float getFloat(String parameterName) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getFloat_L].methodEntry();
+ try {
+ int parameterIndex = validateGetInvocation(parameterName);
+ return getFloat(parameterIndex);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getFloat_L].methodExit();
+ }
+ }
+
+public int getInt(int parameterIndex) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getInt_I].methodEntry();
+ try {
+ String data;
+
+ validateGetInvocation(parameterIndex);
+ inputDesc_[parameterIndex - 1]
+ .checkValidNumericConversion(connection_.locale_);
+ data = getString(parameterIndex);
+ if (data != null) {
+ wasNull_ = false;
+ return Integer.parseInt(data);
+ } else {
+ wasNull_ = true;
+ return 0;
+ }
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getInt_I].methodExit();
+ }
+ }
+
+public int getInt(String parameterName) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getInt_L].methodEntry();
+ try {
+ int parameterIndex = validateGetInvocation(parameterName);
+ return getInt(parameterIndex);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getInt_L].methodExit();
+ }
+ }
+
+public long getLong(int parameterIndex) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getLong_I].methodEntry();
+ try {
+ String data;
+
+ validateGetInvocation(parameterIndex);
+ inputDesc_[parameterIndex - 1]
+ .checkValidNumericConversion(connection_.locale_);
+ data = getString(parameterIndex);
+ if (data != null) {
+ wasNull_ = false;
+ return Long.parseLong(data);
+ } else {
+ wasNull_ = true;
+ return 0;
+ }
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getLong_I].methodExit();
+ }
+ }
+
+public long getLong(String parameterName) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getLong_L].methodEntry();
+ try {
+ int parameterIndex = validateGetInvocation(parameterName);
+ return getLong(parameterIndex);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getLong_L].methodExit();
+ }
+ }
+
+public Object getObject(int parameterIndex) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getObject_I].methodEntry();
+ try {
+ int dataType;
+ byte byteValue;
+ short shortValue;
+ int intValue;
+ long longValue;
+ float floatValue;
+ double doubleValue;
+ boolean booleanValue;
+
+ validateGetInvocation(parameterIndex);
+ dataType = inputDesc_[parameterIndex - 1].dataType_;
+ switch (dataType) {
+ case Types.TINYINT:
+ intValue = getByte(parameterIndex);
+ if (wasNull_)
+ return null;
+ else
+ return new Integer(intValue);
+ case Types.SMALLINT:
+ intValue = getShort(parameterIndex);
+ if (wasNull_)
+ return null;
+ else
+ return new Integer(intValue);
+ case Types.INTEGER:
+ intValue = getInt(parameterIndex);
+ if (wasNull_)
+ return null;
+ else
+ return new Integer(intValue);
+ case Types.BIGINT:
+ longValue = getLong(parameterIndex);
+ if (wasNull_)
+ return null;
+ else
+ return new Long(longValue);
+ case Types.REAL:
+ floatValue = getFloat(parameterIndex);
+ if (wasNull_)
+ return null;
+ else
+ return new Float(floatValue);
+ case Types.FLOAT:
+ case Types.DOUBLE:
+ doubleValue = getDouble(parameterIndex);
+ if (wasNull_)
+ return null;
+ else
+ return new Double(doubleValue);
+ case Types.DECIMAL:
+ case Types.NUMERIC:
+ return getBigDecimal(parameterIndex);
+ case Types.BIT:
+ booleanValue = getBoolean(parameterIndex);
+ if (wasNull_)
+ return null;
+ else
+ return new Boolean(booleanValue);
+ case Types.CHAR:
+ case Types.VARCHAR:
+ case Types.LONGVARCHAR:
+ return getString(parameterIndex);
+ case Types.BINARY:
+ case Types.VARBINARY:
+ case Types.LONGVARBINARY:
+ return getBytes(parameterIndex);
+ case Types.DATE:
+ return getDate(parameterIndex);
+ case Types.TIME:
+ return getTime(parameterIndex);
+ case Types.TIMESTAMP:
+ return getTimestamp(parameterIndex);
+ default:
+ throw Messages.createSQLException(connection_.locale_,
+ "restricted_data_type", null);
+ }
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getObject_I].methodExit();
+ }
+ }
+
+public Object getObject(int parameterIndex, Map map) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getObject_IL].methodEntry();
+ try {
+ Messages.throwUnsupportedFeatureException(connection_.locale_,
+ "getObject()");
+ return null;
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getObject_IL].methodExit();
+ }
+ }
+
+public Object getObject(String parameterName) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getObject_L].methodEntry();
+ try {
+ int parameterIndex = validateGetInvocation(parameterName);
+ return getObject(parameterIndex);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getObject_L].methodExit();
+ }
+ }
+
+public Object getObject(String parameterName, Map map) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getObject_LL].methodEntry();
+ try {
+ int parameterIndex = validateGetInvocation(parameterName);
+ return getObject(parameterIndex, map);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getObject_LL].methodExit();
+ }
+ }
+
+public Ref getRef(int parameterIndex) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getRef_I].methodEntry();
+ try {
+ Messages.throwUnsupportedFeatureException(connection_.locale_,
+ "getRef()");
+ return null;
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getRef_I].methodExit();
+ }
+ }
+
+public Ref getRef(String parameterName) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getRef_L].methodEntry();
+ try {
+ int parameterIndex = validateGetInvocation(parameterName);
+ return getRef(parameterIndex);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getRef_L].methodExit();
+ }
+ }
+
+public short getShort(int parameterIndex) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getShort_I].methodEntry();
+ try {
+ String data;
+
+ validateGetInvocation(parameterIndex);
+ inputDesc_[parameterIndex - 1]
+ .checkValidNumericConversion(connection_.locale_);
+ data = getString(parameterIndex);
+ if (data != null) {
+ wasNull_ = false;
+ return Short.parseShort(data);
+ } else {
+ wasNull_ = true;
+ return 0;
+ }
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getShort_I].methodExit();
+ }
+ }
+
+public short getShort(String parameterName) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getShort_L].methodEntry();
+ try {
+ int parameterIndex = validateGetInvocation(parameterName);
+ return getShort(parameterIndex);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getShort_L].methodExit();
+ }
+ }
+
+public String getString(int parameterIndex) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getString_I].methodEntry();
+ try {
+ validateGetInvocation(parameterIndex);
+ if ((paramValues_ == null) || paramValues_.isNull(parameterIndex)) {
+ wasNull_ = true;
+ return (null);
+ }
+
+ wasNull_ = false;
+ return paramValues_.getString(parameterIndex);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getString_I].methodExit();
+ }
+ }
+
+public String getString(String parameterName) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getString_L].methodEntry();
+ try {
+ int parameterIndex = validateGetInvocation(parameterName);
+ return getString(parameterIndex);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getString_L].methodExit();
+ }
+ }
+
+public Time getTime(int parameterIndex) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getTime_I].methodEntry();
+ try {
+ int dataType;
+ String timeStr;
+ Time retValue;
+
+ validateGetInvocation(parameterIndex);
+ dataType = inputDesc_[parameterIndex - 1].dataType_;
+ if (dataType != Types.CHAR && dataType != Types.VARCHAR
+ && dataType != Types.LONGVARCHAR && dataType != Types.TIME
+ && dataType != Types.TIMESTAMP)
+ throw Messages.createSQLException(connection_.locale_,
+ "restricted_data_type", null);
+ timeStr = getString(parameterIndex);
+ if (timeStr != null) {
+ try {
+ wasNull_ = false;
+ retValue = Time.valueOf(timeStr);
+ } catch (IllegalArgumentException e) {
+ throw Messages.createSQLException(connection_.locale_,
+ "invalid_cast_specification", null);
+ }
+ return retValue;
+ } else {
+ wasNull_ = true;
+ return null;
+ }
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getTime_I].methodExit();
+ }
+ }
+
+public Time getTime(int parameterIndex, Calendar cal) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getTime_IL].methodEntry();
+ try {
+ Time sqlTime;
+ java.util.Date d;
+
+ sqlTime = getTime(parameterIndex);
+ if (sqlTime != null) {
+ if (cal != null) {
+ cal.setTime(sqlTime);
+ d = cal.getTime();
+ sqlTime = new Time(d.getTime());
+ }
+ return sqlTime;
+ } else
+ return (sqlTime);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getTime_IL].methodExit();
+ }
+ }
+
+public Time getTime(String parameterName) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getTime_L].methodEntry();
+ try {
+ int parameterIndex = validateGetInvocation(parameterName);
+ return getTime(parameterIndex);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getTime_L].methodExit();
+ }
+ }
+
+public Time getTime(String parameterName, Calendar cal) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getTime_LL].methodEntry();
+ try {
+ int parameterIndex = validateGetInvocation(parameterName);
+ return getTime(parameterIndex, cal);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getTime_LL].methodExit();
+ }
+ }
+
+public Timestamp getTimestamp(int parameterIndex) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getTimestamp_I].methodEntry();
+ try {
+ int dataType;
+ String timestampStr;
+ Timestamp retValue;
+
+ validateGetInvocation(parameterIndex);
+ dataType = inputDesc_[parameterIndex - 1].dataType_;
+ if (dataType != Types.CHAR && dataType != Types.VARCHAR
+ && dataType != Types.LONGVARCHAR && dataType != Types.DATE
+ && dataType != Types.TIMESTAMP)
+ throw Messages.createSQLException(connection_.locale_,
+ "restricted_data_type", null);
+ timestampStr = getString(parameterIndex);
+ if (timestampStr != null) {
+ try {
+ wasNull_ = false;
+ retValue = Timestamp.valueOf(timestampStr);
+ } catch (IllegalArgumentException e) {
+ throw Messages.createSQLException(connection_.locale_,
+ "invalid_cast_specification", null);
+ }
+ return retValue;
+ } else {
+ wasNull_ = true;
+ return null;
+ }
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getTimestamp_I].methodExit();
+ }
+ }
+
+public Timestamp getTimestamp(int parameterIndex, Calendar cal)
+ throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getTimestamp_IL].methodEntry();
+ try {
+ Timestamp sqlTimestamp;
+ java.util.Date d;
+ int nanos;
+
+ sqlTimestamp = getTimestamp(parameterIndex);
+ if (sqlTimestamp != null) {
+ if (cal != null) {
+ nanos = sqlTimestamp.getNanos();
+ cal.setTime(sqlTimestamp);
+ d = cal.getTime();
+ sqlTimestamp = new Timestamp(d.getTime());
+ sqlTimestamp.setNanos(nanos);
+ }
+ return sqlTimestamp;
+ } else
+ return (sqlTimestamp);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getTimestamp_IL].methodExit();
+ }
+ }
+
+public Timestamp getTimestamp(String parameterName) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getTimestamp_L].methodEntry();
+ try {
+ int parameterIndex = validateGetInvocation(parameterName);
+ return getTimestamp(parameterIndex);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getTimestamp_L].methodExit();
+ }
+ }
+
+public Timestamp getTimestamp(String parameterName, Calendar cal)
+ throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getTimestamp_LL].methodEntry();
+ try {
+ int parameterIndex = validateGetInvocation(parameterName);
+ return getTimestamp(parameterIndex, cal);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getTimestamp_LL].methodExit();
+ }
+ }
+
+public URL getURL(int parameterIndex) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getURL_I].methodEntry();
+ try {
+ clearWarnings();
+ Messages.throwUnsupportedFeatureException(connection_.locale_,
+ "getURL()");
+ return null;
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getURL_I].methodExit();
+ }
+ }
+
+public URL getURL(String parameterName) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getURL_L].methodEntry();
+ try {
+ int parameterIndex = validateGetInvocation(parameterName);
+ return getURL(parameterIndex);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_getURL_L].methodExit();
+ }
+ }
+
+public void registerOutParameter(int parameterIndex, int sqlType)
+ throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_registerOutParameter_II].methodEntry();
+ try {
+ // Ignoring sqlType and scale
+ validateGetInvocation(parameterIndex);
+ if (inputDesc_[parameterIndex - 1].paramMode_ == DatabaseMetaData.procedureColumnOut)
+ inputDesc_[parameterIndex - 1].isValueSet_ = true;
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_registerOutParameter_II].methodExit();
+ }
+ }
+
+public void registerOutParameter(int parameterIndex, int sqlType, int scale)
+ throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_registerOutParameter_III].methodEntry();
+ try {
+ // Ignoring sqlType and scale
+ validateGetInvocation(parameterIndex);
+ if (inputDesc_[parameterIndex - 1].paramMode_ == DatabaseMetaData.procedureColumnOut)
+ inputDesc_[parameterIndex - 1].isValueSet_ = true;
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_registerOutParameter_III].methodExit();
+ }
+ }
+
+public void registerOutParameter(int parameterIndex, int sqlType,
+ String typeName) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_registerOutParameter_IIL].methodEntry();
+ try {
+ // Ignoring sqlType and typeName
+ validateGetInvocation(parameterIndex);
+ if (inputDesc_[parameterIndex - 1].paramMode_ == DatabaseMetaData.procedureColumnOut)
+ inputDesc_[parameterIndex - 1].isValueSet_ = true;
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_registerOutParameter_IIL].methodExit();
+ }
+ }
+
+public void registerOutParameter(String parameterName, int sqlType)
+ throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_registerOutParameter_LI].methodEntry();
+ try {
+ int parameterIndex = validateGetInvocation(parameterName);
+ registerOutParameter(parameterIndex, sqlType);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_registerOutParameter_LI].methodExit();
+ }
+ }
+
+public void registerOutParameter(String parameterName, int sqlType,
+ int scale) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_registerOutParameter_LII].methodEntry();
+ try {
+ int parameterIndex = validateGetInvocation(parameterName);
+ registerOutParameter(parameterIndex, sqlType, scale);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_registerOutParameter_LII].methodExit();
+ }
+ }
+
+public void registerOutParameter(String parameterName, int sqlType,
+ String typeName) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_registerOutParameter_LIL].methodEntry();
+ try {
+ int parameterIndex = validateGetInvocation(parameterName);
+ registerOutParameter(parameterIndex, sqlType, typeName);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_registerOutParameter_LIL].methodExit();
+ }
+ }
+
+public void setAsciiStream(String parameterName, InputStream x, int length)
+ throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setAsciiStream].methodEntry();
+ try {
+ int parameterIndex = validateSetInvocation(parameterName);
+ setAsciiStream(parameterIndex, x, length);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setAsciiStream].methodExit();
+ }
+ }
+
+public void setBigDecimal(String parameterName, BigDecimal x)
+ throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setBigDecimal].methodEntry();
+ try {
+ int parameterIndex = validateSetInvocation(parameterName);
+ setBigDecimal(parameterIndex, x);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setBigDecimal].methodExit();
+ }
+ }
+
+public void setBinaryStream(String parameterName, InputStream x, int length)
+ throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setBinaryStream].methodEntry();
+ try {
+ int parameterIndex = validateSetInvocation(parameterName);
+ setBinaryStream(parameterIndex, x, length);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setBinaryStream].methodExit();
+ }
+ }
+
+public void setBoolean(String parameterName, boolean x) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setBoolean].methodEntry();
+ try {
+ int parameterIndex = validateSetInvocation(parameterName);
+ setBoolean(parameterIndex, x);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setBoolean].methodExit();
+ }
+ }
+
+public void setByte(String parameterName, byte x) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setByte].methodEntry();
+ try {
+ int parameterIndex = validateSetInvocation(parameterName);
+ setByte(parameterIndex, x);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setByte].methodExit();
+ }
+ }
+
+public void setBytes(String parameterName, byte[] x) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setBytes].methodEntry();
+ try {
+ int parameterIndex = validateSetInvocation(parameterName);
+ setBytes(parameterIndex, x);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setBytes].methodExit();
+ }
+ }
+
+public void setCharacterStream(String parameterName, Reader reader,
+ int length) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setCharacterStream].methodEntry();
+ try {
+ int parameterIndex = validateSetInvocation(parameterName);
+ setCharacterStream(parameterIndex, reader, length);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setCharacterStream].methodExit();
+ }
+ }
+
+public void setDate(String parameterName, Date x) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setDate_LL].methodEntry();
+ try {
+ int parameterIndex = validateSetInvocation(parameterName);
+ setDate(parameterIndex, x);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setDate_LL].methodExit();
+ }
+ }
+
+public void setDate(String parameterName, Date x, Calendar cal)
+ throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setDate_LLL].methodEntry();
+ try {
+ int parameterIndex = validateSetInvocation(parameterName);
+ setDate(parameterIndex, x, cal);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setDate_LLL].methodExit();
+ }
+ }
+
+public void setDouble(String parameterName, double x) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setDouble].methodEntry();
+ try {
+ int parameterIndex = validateSetInvocation(parameterName);
+ setDouble(parameterIndex, x);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setDouble].methodExit();
+ }
+ }
+
+public void setFloat(String parameterName, float x) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setFloat].methodEntry();
+ try {
+ int parameterIndex = validateSetInvocation(parameterName);
+ setFloat(parameterIndex, x);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setFloat].methodExit();
+ }
+ }
+
+public void setInt(String parameterName, int x) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setInt].methodEntry();
+ try {
+ int parameterIndex = validateSetInvocation(parameterName);
+ setInt(parameterIndex, x);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setInt].methodExit();
+ }
+ }
+
+public void setLong(String parameterName, long x) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setLong].methodEntry();
+ try {
+ int parameterIndex = validateSetInvocation(parameterName);
+ setLong(parameterIndex, x);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setLong].methodExit();
+ }
+ }
+
+public void setNull(String parameterName, int sqlType) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setNull_LI].methodEntry();
+ try {
+ int parameterIndex = validateSetInvocation(parameterName);
+ setNull(parameterIndex, sqlType);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setNull_LI].methodExit();
+ }
+ }
+
+public void setNull(String parameterName, int sqlType, String typeName)
+ throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setNull_LIL].methodEntry();
+ try {
+ int parameterIndex = validateSetInvocation(parameterName);
+ setNull(parameterIndex, sqlType, typeName);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setNull_LIL].methodExit();
+ }
+ }
+
+public void setObject(String parameterName, Object x) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setObject_LL].methodEntry();
+ try {
+ int parameterIndex = validateSetInvocation(parameterName);
+ setObject(parameterIndex, x);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setObject_LL].methodExit();
+ }
+ }
+
+public void setObject(String parameterName, Object x, int targetSqlType)
+ throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setObject_LLI].methodEntry();
+ try {
+ int parameterIndex = validateSetInvocation(parameterName);
+ setObject(parameterIndex, x, targetSqlType);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setObject_LLI].methodExit();
+ }
+ }
+
+public void setObject(String parameterName, Object x, int targetSqlType,
+ int scale) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setObject_LLII].methodEntry();
+ try {
+ int parameterIndex = validateSetInvocation(parameterName);
+ setObject(parameterIndex, x, targetSqlType, scale);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setObject_LLII].methodExit();
+ }
+ }
+
+public void setShort(String parameterName, short x) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setShort].methodEntry();
+ try {
+ int parameterIndex = validateSetInvocation(parameterName);
+ setShort(parameterIndex, x);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setShort].methodExit();
+ }
+ }
+
+public void setString(String parameterName, String x) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setString].methodEntry();
+ try {
+ int parameterIndex = validateSetInvocation(parameterName);
+ setString(parameterIndex, x);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setString].methodExit();
+ }
+ }
+
+public void setTime(String parameterName, Time x) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setTime_LL].methodEntry();
+ try {
+ int parameterIndex = validateSetInvocation(parameterName);
+ setTime(parameterIndex, x);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setTime_LL].methodExit();
+ }
+ }
+
+public void setTime(String parameterName, Time x, Calendar cal)
+ throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setTime_LLL].methodEntry();
+ try {
+ int parameterIndex = validateSetInvocation(parameterName);
+ setTime(parameterIndex, x, cal);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setTime_LLL].methodExit();
+ }
+ }
+
+public void setTimestamp(String parameterName, Timestamp x)
+ throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setTimestamp_LL].methodEntry();
+ try {
+ int parameterIndex = validateSetInvocation(parameterName);
+ setTimestamp(parameterIndex, x);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setTimestamp_LL].methodExit();
+ }
+ }
+
+public void setTimestamp(String parameterName, Timestamp x, Calendar cal)
+ throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setTimestamp_LLL].methodEntry();
+ try {
+ int parameterIndex = validateSetInvocation(parameterName);
+ setTimestamp(parameterIndex, x, cal);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setTimestamp_LLL].methodExit();
+ }
+ }
+
+ @Deprecated
+public void setUnicodeStream(String parameterName, InputStream x, int length)
+ throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setUnicodeStream].methodEntry();
+ try {
+ int parameterIndex = validateSetInvocation(parameterName);
+ setUnicodeStream(parameterIndex, x, length);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setUnicodeStream].methodExit();
+ }
+ }
+
+public void setURL(String parameterName, URL x) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setURL].methodEntry();
+ try {
+ int parameterIndex = validateSetInvocation(parameterName);
+ setURL(parameterIndex, x);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setURL].methodExit();
+ }
+ }
+
+public boolean wasNull() {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_wasNull].methodEntry();
+ try {
+ return wasNull_;
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_wasNull].methodExit();
+ }
+ }
+
+public boolean execute() throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_execute].methodEntry();
+ try {
+ if (JdbcDebugCfg.traceActive)
+ debug[methodId_execute].traceOut(JdbcDebug.debugLevelStmt,
+ "Pre-executeCall: resultSetMax_ = " + resultSetMax_
+ + ", resultSetIndex_= " + resultSetIndex_
+ + ", isSPJResultSet_= " + isSPJResultSet_);
+
+ /*
+ * RFE: Connection synchronization Connection object is now
+ * synchronized.
+ */
+ long beginTime=0,endTime,timeTaken;
+// if ((T2Driver.queryExecuteTime_ > 0) || (SQLMXDataSource.queryExecuteTime_> 0) ) {
+ if(connection_.t2props.getQueryExecuteTime() > 0) {
+ beginTime=System.currentTimeMillis();
+ }
+ synchronized (connection_) {
+ validateExecuteInvocation();
+ if (inputDesc_ != null) {
+ executeCall(connection_.server_, connection_.getDialogueId_(),
+ connection_.getTxid_(), connection_.autoCommit_,
+ connection_.transactionMode_, stmtId_,
+ inputDesc_.length, getParameters(), queryTimeout_,
+ connection_.iso88591EncodingOverride_);
+ } else
+ executeCall(connection_.server_, connection_.getDialogueId_(),
+ connection_.getTxid_(), connection_.autoCommit_,
+ connection_.transactionMode_, stmtId_, 0, null,
+ queryTimeout_,
+ connection_.iso88591EncodingOverride_);
+ if (JdbcDebugCfg.traceActive)
+ debug[methodId_execute].traceOut(JdbcDebug.debugLevelStmt,
+ "Post-executeCall: resultSetMax_ = "
+ + resultSetMax_ + ", resultSetIndex_ = "
+ + resultSetIndex_ + ", isSPJResultSet_ = "
+ + isSPJResultSet_);
+// if ((T2Driver.queryExecuteTime_ > 0) || (SQLMXDataSource.queryExecuteTime_> 0) ) {
+ if(connection_.t2props.getQueryExecuteTime() > 0) {
+ endTime = System.currentTimeMillis();
+ timeTaken = endTime - beginTime;
+ printQueryExecuteTimeTrace(timeTaken);
+ }
+
+ if (isSPJResultSet_)
+ return firstResultSetExists();
+ else
+ return false;
+ } // End sync
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_execute].methodExit();
+ }
+ }
+
+public int[] executeBatch() throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_executeBatch].methodEntry();
+ try {
+ clearWarnings();
+ Messages.throwUnsupportedFeatureException(connection_.locale_,
+ "executeBatch()");
+ return null;
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_executeBatch].methodExit();
+ }
+ }
+
+public ResultSet executeQuery() throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_executeQuery].methodEntry();
+ try {
+ /*
+ * RFE: Connection synchronization Connection object is now
+ * synchronized.
+ */
+ long beginTime=0,endTime,timeTaken;
+// if ((T2Driver.queryExecuteTime_ > 0) || (SQLMXDataSource.queryExecuteTime_> 0) ) {
+ if(connection_.t2props.getQueryExecuteTime() > 0) {
+ beginTime=System.currentTimeMillis();
+ }
+
+ synchronized (connection_) {
+ validateExecuteInvocation();
+ if (inputDesc_ != null) {
+ executeCall(connection_.server_, connection_.getDialogueId_(),
+ connection_.getTxid_(), connection_.autoCommit_,
+ connection_.transactionMode_, stmtId_,
+ inputDesc_.length, getParameters(), queryTimeout_,
+ connection_.iso88591EncodingOverride_);
+ } else
+ executeCall(connection_.server_, connection_.getDialogueId_(),
+ connection_.getTxid_(), connection_.autoCommit_,
+ connection_.transactionMode_, stmtId_, 0, null,
+ queryTimeout_,
+ connection_.iso88591EncodingOverride_);
+
+// if ((T2Driver.queryExecuteTime_ > 0) || (SQLMXDataSource.queryExecuteTime_> 0) ) {
+ if(connection_.t2props.getQueryExecuteTime() > 0) {
+ endTime = System.currentTimeMillis();
+ timeTaken = endTime - beginTime;
+ printQueryExecuteTimeTrace(timeTaken);
+ }
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_executeQuery]
+ .methodParameters("resultSetMax_= " + resultSetMax_
+ + " resultSetIndex_= " + resultSetIndex_
+ + " isSPJResultSet_= " + isSPJResultSet_
+ + " resultSet_= " + resultSet_);
+ // To initialize and populate the resultSet_ in SPJRS
+ if (isSPJResultSet_)
+ firstResultSetExists();
+
+ return resultSet_;
+ } // End sync
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_executeQuery].methodExit();
+ }
+ }
+
+public int executeUpdate() throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_executeUpdate].methodEntry();
+ try {
+ /*
+ * RFE: Connection synchronization Connection object is now
+ * synchronized.
+ */
+ long beginTime=0,endTime,timeTaken;
+// if ((T2Driver.queryExecuteTime_ > 0) || (SQLMXDataSource.queryExecuteTime_> 0) ) {
+ if(connection_.t2props.getQueryExecuteTime() > 0) {
+ beginTime=System.currentTimeMillis();
+ }
+ synchronized (connection_) {
+ validateExecuteInvocation();
+ if (inputDesc_ != null) {
+ executeCall(connection_.server_, connection_.getDialogueId_(),
+ connection_.getTxid_(), connection_.autoCommit_,
+ connection_.transactionMode_, stmtId_,
+ inputDesc_.length, getParameters(), queryTimeout_,
+ connection_.iso88591EncodingOverride_);
+ } else
+ executeCall(connection_.server_, connection_.getDialogueId_(),
+ connection_.getTxid_(), connection_.autoCommit_,
+ connection_.transactionMode_, stmtId_, 0, null,
+ queryTimeout_,
+ connection_.iso88591EncodingOverride_);
+
+// if ((T2Driver.queryExecuteTime_ > 0) || (SQLMXDataSource.queryExecuteTime_> 0) ) {
+ if(connection_.t2props.getQueryExecuteTime() > 0) {
+ endTime = System.currentTimeMillis();
+ timeTaken = endTime - beginTime;
+ printQueryExecuteTimeTrace(timeTaken);
+ }
+ return rowCount_;
+ } // End sync
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_executeUpdate].methodExit();
+ }
+ }
+
+ void cpqPrepareCall(String server, long dialogueId, int txid,
+ boolean autoCommit, String moduleName, int moduleVersion,
+ long moduleTimestamp, String stmtName, int queryTimeout,
+ int holdability) {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_cpqPrepareCall].methodEntry();
+ try {
+ /*
+ * RFE: Connection synchronization Connection object is now
+ * synchronized.
+ */
+ synchronized (connection_) {
+ // Call adding the current fetch size and select flag
+ cpqPrepareCall(server, dialogueId, txid, autoCommit,
+ connection_.transactionMode_, moduleName,
+ moduleVersion, moduleTimestamp, stmtName, queryTimeout,
+ holdability, fetchSize_);
+ } // End sync
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_cpqPrepareCall].methodExit();
+ }
+ }
+
+ // Other methods
+protected void validateGetInvocation(int parameterIndex)
+ throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_validateGetInvocation_I].methodEntry();
+ try {
+ clearWarnings();
+ if (connection_.isClosed_)
+ throw Messages.createSQLException(connection_.locale_,
+ "invalid_connection", null);
+ if (isClosed_)
+ throw Messages.createSQLException(connection_.locale_,
+ "invalid_statement", null);
+ if (inputDesc_ == null)
+ throw Messages.createSQLException(connection_.locale_,
+ "not_a_output_parameter", null);
+ if (parameterIndex < 1 || parameterIndex > inputDesc_.length)
+ throw Messages.createSQLException(connection_.locale_,
+ "invalid_parameter_index", null);
+ if (inputDesc_[parameterIndex - 1].paramMode_ != DatabaseMetaData.procedureColumnInOut
+ && inputDesc_[parameterIndex - 1].paramMode_ != DatabaseMetaData.procedureColumnOut)
+ throw Messages.createSQLException(connection_.locale_,
+ "not_a_output_parameter", null);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_validateGetInvocation_I].methodExit();
+ }
+ }
+
+protected int validateGetInvocation(String parameterName)
+ throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_validateGetInvocation_L].methodEntry();
+ try {
+ int i;
+
+ if (isClosed_)
+ throw Messages.createSQLException(connection_.locale_,
+ "invalid_statement", null);
+ if (inputDesc_ == null)
+ throw Messages.createSQLException(connection_.locale_,
+ "not_a_output_parameter", null);
+ for (i = 0; i < inputDesc_.length; i++) {
+ if (parameterName.equalsIgnoreCase(inputDesc_[i].name_))
+ return i + 1;
+ }
+ throw Messages.createSQLException(connection_.locale_,
+ "invalid_parameter_name", null);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_validateGetInvocation_L].methodExit();
+ }
+ }
+
+private int validateSetInvocation(String parameterName) throws SQLException {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_validateSetInvocation].methodEntry();
+ try {
+ int i;
+
+ if (isClosed_)
+ throw Messages.createSQLException(connection_.locale_,
+ "stmt_closed", null);
+ if (inputDesc_ == null)
+ throw Messages.createSQLException(connection_.locale_,
+ "invalid_parameter_index", null);
+ for (i = 0; i < inputDesc_.length; i++) {
+ if (parameterName.equalsIgnoreCase(inputDesc_[i].name_))
+ return i + 1;
+ }
+ throw Messages.createSQLException(connection_.locale_,
+ "invalid_parameter_name", null);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_validateSetInvocation].methodExit();
+ }
+ }
+
+ void setExecuteCallOutputs(DataWrapper wrapper, short returnResultSet,
+ int txid, int ResultSetMax, int ResultSetIndex, boolean isSPJRS) {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setExecuteCallOutputs].methodEntry();
+ try {
+ paramValues_ = wrapper;
+ returnResultSet_ = returnResultSet;
+ connection_.setTxid_(txid);
+ resultSetMax_ = ResultSetMax;
+ resultSetIndex_ = ResultSetIndex;
+ isSPJResultSet_ = isSPJRS;
+
+ if (JdbcDebugCfg.traceActive)
+ debug[methodId_setExecuteCallOutputs].traceOut(
+ JdbcDebug.debugLevelStmt, "paramValues_ = "
+ + paramValues_ + ", returnResultSet_ = "
+ + returnResultSet_ + ", connection_.txid_ = "
+ + connection_.getTxid_() + ", resultSetMax_ = "
+ + resultSetMax_ + ", resultSetIndex_ = "
+ + resultSetIndex_ + ", isSPJResultSet_ = "
+ + isSPJResultSet_);
+ }finally {
+ if (JdbcDebugCfg.entryActive)
+ debug[methodId_setExecuteCallOutputs].methodExit();
+ }
+ }
+
+ // Constructors with access specifier as "default"
+ SQLMXCallableStatement(SQLMXConnection connection, String sql)
+ throws SQLException {
+ super(connection, sql);
+ if (JdbcDebugCfg.entryActive) {
+ debug[methodId_SQLMXCallableStatement_LL].methodEntry();
+ debug[methodId_SQLMXCallableStatement_LL].methodExit();
+ }
+ }
+
+ SQLMXCallableStatement(SQLMXConnection connection, String sql,
+ int resultSetType, int resultSetConcurrency) throws SQLException {
+ super(connection, sql, resultSetType, resultSetConcurrency);
+ if (JdbcDebugCfg.entryActive) {
+ debug[methodId_SQLMXCallableStatement_LLII].methodEntry();
+ debug[methodId_SQLMXCallableStatement_LLII].methodExit();
+ }
+ }
+
+ SQLMXCallableStatement(SQLMXConnection connection, String sql,
+ int resultSetType, int resultSetConcurrency,
+ int resultSetHoldability) throws SQLException {
+ super(connection, sql, resultSetType, resultSetConcurrency,
+ resultSetHoldability);
+ if (JdbcDebugCfg.entryActive) {
+ debug[methodId_SQLMXCallableStatement_LLIII].methodEntry();
+ debug[methodId_SQLMXCallableStatement_LLIII].methodExit();
+ }
+ }
+
+ SQLMXCallableStatement(SQLMXConnection connection, String moduleName,
+ int moduleVersion, long moduleTimestamp, String stmtName) {
+ super(connection, moduleName, moduleVersion, moduleTimestamp, stmtName,
+ false, connection.holdability_);
+ if (JdbcDebugCfg.entryActive) {
+ debug[methodId_SQLMXCallableStatement_LLIJL].methodEntry();
+ debug[methodId_SQLMXCallableStatement_LLIJL].methodExit();
+ }
+ }
+
+ // native methods
+ native void prepareCall(String server, long dialogueId, int txid,
+ boolean autoCommit, int txnMode, String stmtLabel, String sql,
+ int queryTimeout, int holdability, int fetchSize);
+
+//Venu changed dialogueId and stmtId from int to long for 64 bit
+private native void executeCall(String server, long dialogueId, int txid,
+ boolean autoCommit, int txnMode, long stmtId, int inputParamCount,
+ Object inputParamValues, int queryTimeout, String iso88591Encoding);
+
+ // This method is used for internal support of SQLJ.
+ // Not used directly by SQLJ, so can be modified.
+ native void cpqPrepareCall(String server, long dialogueId, int txid,
+ boolean autoCommit, int txnMode, String moduleName,
+ int moduleVersion, long moduleTimestamp, String stmtName,
+ int queryTimeout, int holdability, int fetchSize);
+
+ // fields
+ boolean wasNull_;
+ short returnResultSet_;
+ DataWrapper paramValues_;
+
+private static int methodId_getArray_I = 0;
+private static int methodId_getArray_L = 1;
+private static int methodId_getBigDecimal_I = 2;
+private static int methodId_getBigDecimal_II = 3;
+private static int methodId_getBigDecimal_L = 4;
+private static int methodId_getBigDecimal_LI = 5;
+private static int methodId_getBlob_I = 6;
+private static int methodId_getBlob_L = 7;
+private static int methodId_getBoolean_I = 8;
+private static int methodId_getBoolean_L = 9;
+private static int methodId_getByte_I = 10;
+private static int methodId_getByte_L = 11;
+private static int methodId_getBytes_I = 12;
+private static int methodId_getBytes_L = 13;
+private static int methodId_getClob_I = 14;
+private static int methodId_getClob_L = 15;
+private static int methodId_getDate_I = 16;
+private static int methodId_getDate_IL = 17;
+private static int methodId_getDate_L = 18;
+private static int methodId_getDate_LL = 19;
+private static int methodId_getDouble_I = 20;
+private static int methodId_getDouble_L = 21;
+private static int methodId_getFloat_I = 22;
+private static int methodId_getFloat_L = 23;
+private static int methodId_getInt_I = 24;
+private static int methodId_getInt_L = 25;
+private static int methodId_getLong_I = 26;
+private static int methodId_getLong_L = 27;
+private static int methodId_getObject_I = 28;
+private static int methodId_getObject_IL = 29;
+private static int methodId_getObject_L = 30;
+private static int methodId_getObject_LL = 31;
+private static int methodId_getRef_I = 32;
+private static int methodId_getRef_L = 33;
+private static int methodId_getShort_I = 34;
+private static int methodId_getShort_L = 35;
+private static int methodId_getString_I = 36;
+private static int methodId_getString_L = 37;
+private static int methodId_getTime_I = 38;
+private static int methodId_getTime_IL = 39;
+private static int methodId_getTime_L = 40;
+private static int methodId_getTime_LL = 41;
+private static int methodId_getTimestamp_I = 42;
+private static int methodId_getTimestamp_IL = 43;
+private static int methodId_getTimestamp_L = 44;
+private static int methodId_getTimestamp_LL = 45;
+private static int methodId_getURL_I = 46;
+private static int methodId_getURL_L = 47;
+private static int methodId_registerOutParameter_II = 48;
+private static int methodId_registerOutParameter_III = 49;
+private static int methodId_registerOutParameter_IIL = 50;
+private static int methodId_registerOutParameter_LI = 51;
+private static int methodId_registerOutParameter_LII = 52;
+private static int methodId_registerOutParameter_LIL = 53;
+private static int methodId_setAsciiStream = 54;
+private static int methodId_setBigDecimal = 55;
+private static int methodId_setBinaryStream = 56;
+private static int methodId_setBoolean = 57;
+private static int methodId_setDate_LL = 58;
+private static int methodId_setDate_LLL = 59;
+private static int methodId_setDouble = 60;
+private static int methodId_setFloat = 61;
+private static int methodId_setInt = 62;
+private static int methodId_setLong = 63;
+private static int methodId_setNull_LI = 64;
+private static int methodId_setNull_LIL = 65;
+private static int methodId_setObject_LL = 66;
+private static int methodId_setObject_LLI = 67;
+private static int methodId_setObject_LLII = 68;
+private static int methodId_setShort = 69;
+private static int methodId_setString = 70;
+private static int methodId_setTime_LL = 71;
+private static int methodId_setTime_LLL = 72;
+private static int methodId_setTimestamp_LL = 73;
+private static int methodId_setTimestamp_LLL = 74;
+private static int methodId_setUnicodeStream = 75;
+private static int methodId_setURL = 76;
+private static int methodId_wasNull = 77;
+private static int methodId_execute = 78;
+private static int methodId_executeBatch = 79;
+private static int methodId_executeQuery = 80;
+private static int methodId_executeUpdate = 81;
+private static int methodId_cpqPrepareCall = 82;
+private static int methodId_validateGetInvocation_I = 83;
+private static int methodId_validateGetInvocation_L = 84;
+private static int methodId_validateSetInvocation = 85;
+private static int methodId_setExecuteCallOutputs = 86;
+private static int methodId_setByte = 87;
+private static int methodId_setBytes = 88;
+private static int methodId_setCharacterStream = 89;
+private static int methodId_SQLMXCallableStatement_LL = 90;
+private static int methodId_SQLMXCallableStatement_LLII = 91;
+private static int methodId_SQLMXCallableStatement_LLIII = 92;
+private static int methodId_SQLMXCallableStatement_LLIJL = 93;
+private static int totalMethodIds = 94;
+private static JdbcDebug[] debug;
+
+ static {
+ String className = "SQLMXCallableStatement";
+ if (JdbcDebugCfg.entryActive) {
+ debug = new JdbcDebug[totalMethodIds];
+ debug[methodId_getArray_I] = new JdbcDebug(className, "getArray[I]");
+ debug[methodId_getArray_L] = new JdbcDebug(className, "getArray[L]");
+ debug[methodId_getBigDecimal_I] = new JdbcDebug(className,
+ "getBigDecimal[I]");
+ debug[methodId_getBigDecimal_II] = new JdbcDebug(className,
+ "getBigDecimal[II]");
+ debug[methodId_getBigDecimal_L] = new JdbcDebug(className,
+ "getBigDecimal[L]");
+ debug[methodId_getBigDecimal_LI] = new JdbcDebug(className,
+ "getBigDecimal[LI]");
+ debug[methodId_getBlob_I] = new JdbcDebug(className, "getBlob[I]");
+ debug[methodId_getBlob_L] = new JdbcDebug(className, "getBlob[L]");
+ debug[methodId_getBoolean_I] = new JdbcDebug(className,
+ "getBoolean[I]");
+ debug[methodId_getBoolean_L] = new JdbcDebug(className,
+ "getBoolean[L]");
+ debug[methodId_getByte_I] = new JdbcDebug(className, "getByte[I]");
+ debug[methodId_getByte_L] = new JdbcDebug(className, "getByte[L]");
+ debug[methodId_getBytes_I] = new JdbcDebug(className, "getBytes[I]");
+ debug[methodId_getBytes_L] = new JdbcDebug(className, "getBytes[L]");
+ debug[methodId_getClob_I] = new JdbcDebug(className, "getClob[I]");
+ debug[methodId_getClob_L] = new JdbcDebug(className, "getClob[L]");
+ debug[methodId_getDate_I] = new JdbcDebug(className, "getDate[I]");
+ debug[methodId_getDate_IL] = new JdbcDebug(className, "getDate[IL]");
+ debug[methodId_getDate_L] = new JdbcDebug(className, "getDate[L]");
+ debug[methodId_getDate_LL] = new JdbcDebug(className, "getDate[LL]");
+ debug[methodId_getDouble_I] = new JdbcDebug(className,
+ "getDouble[I]");
+ debug[methodId_getDouble_L] = new JdbcDebug(className,
+ "getDouble[L]");
+ debug[methodId_getFloat_I] = new JdbcDebug(className, "getFloat[I]");
+ debug[methodId_getFloat_L] = new JdbcDebug(className, "getFloat[L]");
+ debug[methodId_getInt_I] = new JdbcDebug(className, "getInt[I]");
+ debug[methodId_getInt_L] = new JdbcDebug(className, "getInt[L]");
+ debug[methodId_getLong_I] = new JdbcDebug(className, "getLong[I]");
+ debug[methodId_getLong_L] = new JdbcDebug(className, "getLong[L]");
+ debug[methodId_getObject_I] = new JdbcDebug(className,
+ "getObject[I]");
+ debug[methodId_getObject_IL] = new JdbcDebug(className,
+ "getObject[IL]");
+ debug[methodId_getObject_L] = new JdbcDebug(className,
+ "getObject[L]");
+ debug[methodId_getObject_LL] = new JdbcDebug(className,
+ "getObject[LL]");
+ debug[methodId_getRef_I] = new JdbcDebug(className, "getRef[I]");
+ debug[methodId_getRef_L] = new JdbcDebug(className, "getRef[L]");
+ debug[methodId_getShort_I] = new JdbcDebug(className, "getShort[I]");
+ debug[methodId_getShort_L] = new JdbcDebug(className, "getShort[L]");
+ debug[methodId_getString_I] = new JdbcDebug(className,
+ "getString[I]");
+ debug[methodId_getString_L] = new JdbcDebug(className,
+ "getString[L]");
+ debug[methodId_getTime_I] = new JdbcDebug(className, "getTime[I]");
+ debug[methodId_getTime_IL] = new JdbcDebug(className, "getTime[IL]");
+ debug[methodId_getTime_L] = new JdbcDebug(className, "getTime[L]");
+ debug[methodId_getTime_LL] = new JdbcDebug(className, "getTime[LL]");
+ debug[methodId_getTimestamp_I] = new JdbcDebug(className,
+ "getTimestamp[I]");
+ debug[methodId_getTimestamp_IL] = new JdbcDebug(className,
+ "getTimestamp[IL]");
+ debug[methodId_getTimestamp_L] = new JdbcDebug(className,
+ "getTimestamp[L]");
+ debug[methodId_getTimestamp_LL] = new JdbcDebug(className,
+ "getTimestamp[LL]");
+ debug[methodId_getURL_I] = new JdbcDebug(className, "getURL[I]");
+ debug[methodId_getURL_L] = new JdbcDebug(className, "getURL[L]");
+ debug[methodId_registerOutParameter_II] = new JdbcDebug(className,
+ "registerOutParameter[II]");
+ debug[methodId_registerOutParameter_III] = new JdbcDebug(className,
+ "registerOutParameter[III]");
+ debug[methodId_registerOutParameter_IIL] = new JdbcDebug(className,
+ "registerOutParameter[IIL]");
+ debug[methodId_registerOutParameter_LI] = new JdbcDebug(className,
+ "registerOutParameter[LI]");
+ debug[methodId_registerOutParameter_LII] = new JdbcDebug(className,
+ "registerOutParameter[LII]");
+ debug[methodId_registerOutParameter_LIL] = new JdbcDebug(className,
+ "registerOutParameter[LIL]");
+ debug[methodId_setAsciiStream] = new JdbcDebug(className,
+ "setAsciiStream");
+ debug[methodId_setBigDecimal] = new JdbcDebug(className,
+ "setBigDecimal");
+ debug[methodId_setBinaryStream] = new JdbcDebug(className,
+ "setBinaryStream");
+ debug[methodId_setBoolean] = new JdbcDebug(className, "setBoolean");
+ debug[methodId_setDate_LL] = new JdbcDebug(className, "setDate[LL]");
+ debug[methodId_setDate_LLL] = new JdbcDebug(className,
+ "setDate[LLL]");
+ debug[methodId_setDouble] = new JdbcDebug(className, "setDouble");
+ debug[methodId_setFloat] = new JdbcDebug(className, "setFloat");
+ debug[methodId_setInt] = new JdbcDebug(className, "setInt");
+ debug[methodId_setLong] = new JdbcDebug(className, "setLong");
+ debug[methodId_setNull_LI] = new JdbcDebug(className, "setNull[LI]");
+ debug[methodId_setNull_LIL] = new JdbcDebug(className,
+ "setNull[LIL]");
+ debug[methodId_setObject_LL] = new JdbcDebug(className,
+ "setObject[LL]");
+ debug[methodId_setObject_LLI] = new JdbcDebug(className,
+ "setObject[LLI]");
+ debug[methodId_setObject_LLII] = new JdbcDebug(className,
+ "setObject[LLII]");
+ debug[methodId_setShort] = new JdbcDebug(className, "setShort");
+ debug[methodId_setString] = new JdbcDebug(className, "setString");
+ debug[methodId_setTime_LL] = new JdbcDebug(className, "setTime[LL]");
+ debug[methodId_setTime_LLL] = new JdbcDebug(className,
+ "setTime[LLL]");
+ debug[methodId_setTimestamp_LL] = new JdbcDebug(className,
+ "setTimestamp[LL]");
+ debug[methodId_setTimestamp_LLL] = new JdbcDebug(className,
+ "setTimestamp[LLL]");
+ debug[methodId_setUnicodeStream] = new JdbcDebug(className,
+ "setUnicodeStream");
+ debug[methodId_setURL] = new JdbcDebug(className, "setURL");
+ debug[methodId_wasNull] = new JdbcDebug(className, "wasNull");
+ debug[methodId_execute] = new JdbcDebug(className, "execute");
+ debug[methodId_executeBatch] = new JdbcDebug(className,
+ "executeBatch");
+ debug[methodId_executeQuery] = new JdbcDebug(className,
+ "executeQuery");
+ debug[methodId_executeUpdate] = new JdbcDebug(className,
+ "executeUpdate");
+ debug[methodId_cpqPrepareCall] = new JdbcDebug(className,
+ "cpqPrepareCall");
+ debug[methodId_validateGetInvocation_I] = new JdbcDebug(className,
+ "validateGetInvocation[I]");
+ debug[methodId_validateGetInvocation_L] = new JdbcDebug(className,
+ "validateGetInvocation[L]");
+ debug[methodId_validateSetInvocation] = new JdbcDebug(className,
+ "validateSetInvocation");
+ debug[methodId_setExecuteCallOutputs] = new JdbcDebug(className,
+ "setExecuteCallOutputs");
+ debug[methodId_setByte] = new JdbcDebug(className, "setByte");
+ debug[methodId_setBytes] = new JdbcDebug(className, "setBytes");
+ debug[methodId_setCharacterStream] = new JdbcDebug(className,
+ "setCharacterStream");
+ debug[methodId_SQLMXCallableStatement_LL] = new JdbcDebug(
+ className, "SQLMXCallableStatement[LL]");
+ debug[methodId_SQLMXCallableStatement_LLII] = new JdbcDebug(
+ className, "SQLMXCallableStatement[LLII]");
+ debug[methodId_SQLMXCallableStatement_LLIII] = new JdbcDebug(
+ className, "SQLMXCallableStatement[LLIII]");
+ debug[methodId_SQLMXCallableStatement_LLIJL] = new JdbcDebug(
+ className, "SQLMXCallableStatement[LLIJL]");
+ }
+ }
+public RowId getRowId(int parameterIndex) throws SQLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+public RowId getRowId(String parameterName) throws SQLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+public void setRowId(String parameterName, RowId x) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+public void setNString(String parameterName, String value)
+ throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+public void setNCharacterStream(String parameterName, Reader value,
+ long length) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+public void setNClob(String parameterName, NClob value) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+public void setClob(String parameterName, Reader reader, long length)
+ throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+public void setBlob(String parameterName, InputStream inputStream,
+ long length) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+public void setNClob(String parameterName, Reader reader, long length)
+ throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+public NClob getNClob(int parameterIndex) throws SQLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+public NClob getNClob(String parameterName) throws SQLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+public void setSQLXML(String parameterName, SQLXML xmlObject)
+ throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+public SQLXML getSQLXML(int parameterIndex) throws SQLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+public SQLXML getSQLXML(String parameterName) throws SQLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+public String getNString(int parameterIndex) throws SQLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+public String getNString(String parameterName) throws SQLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+public Reader getNCharacterStream(int parameterIndex) throws SQLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+public Reader getNCharacterStream(String parameterName) throws SQLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+public Reader getCharacterStream(int parameterIndex) throws SQLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+public Reader getCharacterStream(String parameterName) throws SQLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+public void setBlob(String parameterName, Blob x) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+public void setClob(String parameterName, Clob x) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+public void setAsciiStream(String parameterName, InputStream x, long length)
+ throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+public void setBinaryStream(String parameterName, InputStream x, long length)
+ throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+public void setCharacterStream(String parameterName, Reader reader,
+ long length) throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+public void setAsciiStream(String parameterName, InputStream x)
+ throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+public void setBinaryStream(String parameterName, InputStream x)
+ throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+public void setCharacterStream(String parameterName, Reader reader)
+ throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+public void setNCharacterStream(String parameterName, Reader value)
+ throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+public void setClob(String parameterName, Reader reader)
+ throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+public void setBlob(String parameterName, InputStream inputStream)
+ throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+public void setNClob(String parameterName, Reader reader)
+ throws SQLException {
+ // TODO Auto-generated method stub
+
+ }
+
+public Object getObject(int parameterIndex, Class type)
+ throws SQLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+public Object getObject(String parameterName, Class type)
+ throws SQLException {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+public byte[] getSQLBytes(int parameterIndex) throws SQLException {
+ return paramValues_.getSQLBytes(parameterIndex);
+ }
+}