trafodion-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dbirds...@apache.org
Subject [38/44] incubator-trafodion git commit: Refact package name
Date Tue, 18 Apr 2017 23:52:58 GMT
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);
+    }
+}


Mime
View raw message