mirror of
https://github.com/2003scape/deep-c-rsc.git
synced 2024-03-22 05:49:51 -04:00
1555 lines
68 KiB
Java
1555 lines
68 KiB
Java
/*
|
|
* This file is modified by Ivan Maidanski <ivmai@ivmaisoft.com>
|
|
* Project name: JCGO-SUNAWT (http://www.ivmaisoft.com/jcgo/)
|
|
*/
|
|
|
|
/*
|
|
* @(#)JdbcOdbcCallableStatement.java @(#)JdbcOdbcCallableStatement.java 1.49 03/01/23
|
|
*
|
|
* Copyright 2003 Sun Microsystems, Inc. All rights reserved.
|
|
* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
|
|
*/
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// Module: JdbcOdbcCallableStatement.java
|
|
//
|
|
// Description: Impementation of the CallableStatement interface class
|
|
//
|
|
// Product: JDBCODBC (Java DataBase Connectivity using
|
|
// Open DataBase Connectivity)
|
|
//
|
|
// Author: Karl Moss
|
|
//
|
|
// Date: March, 1996
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
package sun.jdbc.odbc;
|
|
|
|
import java.sql.*;
|
|
import java.util.Map;
|
|
import java.util.Calendar;
|
|
import java.math.BigDecimal;
|
|
|
|
public class JdbcOdbcCallableStatement
|
|
extends JdbcOdbcPreparedStatement
|
|
implements java.sql.CallableStatement {
|
|
|
|
//====================================================================
|
|
// We need to save registerOutParameter's scale parameters
|
|
// for calls to getObject(BigDecimal);
|
|
// We will use an array of bytes to save space (scale will never be
|
|
// more than 127.
|
|
public byte scalez[]=new byte[200];
|
|
//====================================================================
|
|
|
|
//====================================================================
|
|
// Public methods
|
|
//====================================================================
|
|
|
|
//--------------------------------------------------------------------
|
|
// Constructor
|
|
// Perform any necessary initialization.
|
|
//--------------------------------------------------------------------
|
|
|
|
public JdbcOdbcCallableStatement (
|
|
JdbcOdbcConnectionInterface con)
|
|
{
|
|
super (con);
|
|
lastParameterNull = false;
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
// registerOutParameter
|
|
// Before executing a stored procedure call you must explicitly
|
|
// call registerOutParameter to register the java.sql.Type of each
|
|
// out parameter.
|
|
// Note that all parameters are bound to a SQL_C_CHAR data type,
|
|
// so the resulting buffer is a string. When retrieving the value
|
|
// of the output parameter (with getXXXX), the buffer will be converted
|
|
// to a String first, then the appropriate data type for the
|
|
// getXXXX method.
|
|
//--------------------------------------------------------------------
|
|
|
|
public void registerOutParameter (
|
|
int parameterIndex,
|
|
int sqlType)
|
|
throws SQLException
|
|
{
|
|
registerOutParameter (parameterIndex, sqlType, 0);
|
|
}
|
|
|
|
// You must also specify the scale for numeric/decimal types:
|
|
public void registerOutParameter (
|
|
int parameterIndex,
|
|
int sqlType,
|
|
int scale)
|
|
throws SQLException
|
|
{
|
|
// Set the sql type for this OUT parameter
|
|
|
|
setSqlType (parameterIndex, sqlType);
|
|
|
|
// Save the scale in scalez[]
|
|
if (parameterIndex <= 200)
|
|
scalez[parameterIndex]=(byte)scale;
|
|
|
|
// Indicate that this is an output parameter
|
|
setOutputParameter (parameterIndex, true);
|
|
|
|
// First, allocate a buffer to bind the output parameter
|
|
// to.
|
|
|
|
int maxLen;
|
|
|
|
switch (sqlType) {
|
|
case Types.DATE:
|
|
maxLen = 10;
|
|
break;
|
|
case Types.TIME:
|
|
maxLen = 8;
|
|
break;
|
|
case Types.TIMESTAMP:
|
|
maxLen = 15;
|
|
if (scale > 0) {
|
|
maxLen += (scale + 1);
|
|
}
|
|
break;
|
|
case Types.BIT:
|
|
maxLen = 3;
|
|
break;
|
|
case Types.TINYINT:
|
|
maxLen = 4;
|
|
break;
|
|
case Types.SMALLINT:
|
|
maxLen = 6;
|
|
break;
|
|
case Types.INTEGER:
|
|
maxLen = 11;
|
|
break;
|
|
case Types.BIGINT:
|
|
maxLen = 20;
|
|
break;
|
|
case Types.REAL:
|
|
maxLen = 13;
|
|
break;
|
|
case Types.FLOAT:
|
|
case Types.DOUBLE:
|
|
maxLen = 22;
|
|
break;
|
|
case Types.DECIMAL:
|
|
case Types.NUMERIC:
|
|
maxLen = 38;
|
|
break;
|
|
default:
|
|
// Get the precision for the SQL type.
|
|
maxLen = getPrecision (sqlType);
|
|
if ((maxLen <= 0) ||
|
|
(maxLen > JdbcOdbcLimits.DEFAULT_IN_PRECISION)) {
|
|
maxLen = JdbcOdbcLimits.DEFAULT_IN_PRECISION;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// Get the buffer to be used for the output length
|
|
|
|
byte dataLen[] = getLengthBuf (parameterIndex);
|
|
|
|
// Convert the given Java SQL type to an ODBC SQL type
|
|
sqlType = OdbcDef.jdbcTypeToOdbc (sqlType);
|
|
long buffers[]=new long[4];
|
|
buffers[0]=0;
|
|
buffers[1]=0;
|
|
buffers[2]=0;
|
|
buffers[3]=0;
|
|
byte[] dataBuf = null;
|
|
|
|
if (boundParams[parameterIndex - 1].isInOutParameter() && boundParams[parameterIndex - 1].boundValue == null) {
|
|
dataBuf = null;
|
|
} else {
|
|
dataBuf = allocBindBuf (parameterIndex, maxLen + 1);
|
|
}
|
|
|
|
if (boundParams[parameterIndex - 1].isInOutParameter()) {
|
|
if (boundParams[parameterIndex - 1].boundValue == null) {
|
|
OdbcApi.SQLBindInOutParameterNull (hStmt, parameterIndex,
|
|
sqlType, maxLen, boundParams[parameterIndex - 1].scale,
|
|
dataLen, buffers);
|
|
} else if(sqlType == Types.INTEGER) { // bug 4412437 - begin
|
|
if(boundParams[parameterIndex - 1].boundType == Types.INTEGER) {
|
|
OdbcApi.SQLBindInOutParameterFixed(hStmt, parameterIndex, sqlType, maxLen, dataBuf,
|
|
dataLen, buffers);
|
|
} else {
|
|
throw new SQLException("Type mismatch between the set function and registerOutParameter");
|
|
}
|
|
} else if(sqlType == Types.BIT) {
|
|
if(boundParams[parameterIndex - 1].boundType == Types.BIT) {
|
|
OdbcApi.SQLBindInOutParameterFixed(hStmt, parameterIndex, sqlType, maxLen, dataBuf,
|
|
dataLen, buffers);
|
|
} else {
|
|
throw new SQLException("Type mismatch between the set function and registerOutParameter");
|
|
}
|
|
} else if(sqlType == Types.TINYINT) {
|
|
if(boundParams[parameterIndex - 1].boundType == Types.TINYINT) {
|
|
OdbcApi.SQLBindInOutParameterFixed(hStmt, parameterIndex, sqlType, maxLen, dataBuf,
|
|
dataLen, buffers);
|
|
} else {
|
|
throw new SQLException("Type mismatch between the set function and registerOutParameter");
|
|
}
|
|
} else if(sqlType == Types.SMALLINT) {
|
|
if(boundParams[parameterIndex - 1].boundType == Types.SMALLINT) {
|
|
OdbcApi.SQLBindInOutParameterFixed(hStmt, parameterIndex, sqlType, maxLen, dataBuf,
|
|
dataLen, buffers);
|
|
} else {
|
|
throw new SQLException("Type mismatch between the set function and registerOutParameter");
|
|
}
|
|
// Fix 4532167. Types.FLOAT is equivalent to Types.DOUBLE.
|
|
} else if(sqlType == Types.DOUBLE || sqlType == Types.FLOAT || sqlType == Types.REAL) {
|
|
if(boundParams[parameterIndex - 1].boundType == Types.DOUBLE ||
|
|
boundParams[parameterIndex - 1].boundType == Types.FLOAT ||
|
|
boundParams[parameterIndex - 1].boundType == Types.REAL) {
|
|
OdbcApi.SQLBindInOutParameterFixed(hStmt, parameterIndex, Types.DOUBLE, maxLen, dataBuf,
|
|
dataLen, buffers);
|
|
} else {
|
|
throw new SQLException("Type mismatch between the set function and registerOutParameter");
|
|
}
|
|
} else if(sqlType == Types.BIGINT) {//4532162
|
|
if(boundParams[parameterIndex - 1].boundType == Types.BIGINT) {
|
|
OdbcApi.SQLBindInOutParameterFixed(hStmt, parameterIndex, sqlType, maxLen, dataBuf,
|
|
dataLen, buffers);
|
|
} else {
|
|
throw new SQLException("Type mismatch between the set function and registerOutParameter");
|
|
}
|
|
} else if(sqlType == Types.CHAR || sqlType == Types.VARCHAR) {
|
|
if(boundParams[parameterIndex - 1].boundType == Types.CHAR) {
|
|
byte[] newDataBuf = new byte[maxLen+1];
|
|
for(int i = 0; i < newDataBuf.length; i++) {
|
|
newDataBuf[i] = '\0';
|
|
}
|
|
for(int i = 0; i < dataBuf.length; i++) {
|
|
newDataBuf[i] = dataBuf[i];
|
|
}
|
|
boundParams[parameterIndex-1].resetBindDataBuffer(newDataBuf);
|
|
OdbcApi.SQLBindInOutParameterStr(hStmt, parameterIndex, sqlType, maxLen, newDataBuf,
|
|
dataLen, buffers, OdbcDef.SQL_NTS);
|
|
} else {
|
|
throw new SQLException("Type mismatch between the set function and registerOutParameter");
|
|
}
|
|
} else if(sqlType == Types.BINARY || sqlType == Types.VARBINARY ) {
|
|
if(boundParams[parameterIndex - 1].boundType == Types.BINARY ||
|
|
boundParams[parameterIndex - 1].boundType == Types.VARBINARY ) { // 4532171
|
|
byte[] newDataBuf = new byte[maxLen+1];
|
|
for(int i = 0; i < newDataBuf.length; i++) {
|
|
newDataBuf[i] = 0;
|
|
}
|
|
for(int i = 0; i < dataBuf.length; i++) {
|
|
newDataBuf[i] = dataBuf[i];
|
|
}
|
|
boundParams[parameterIndex-1].resetBindDataBuffer(newDataBuf);
|
|
OdbcApi.SQLBindInOutParameterBin(hStmt, parameterIndex, sqlType, maxLen, newDataBuf,
|
|
dataLen, buffers, dataBuf.length);
|
|
} else {
|
|
throw new SQLException("Type mismatch between the set function and registerOutParameter");
|
|
}
|
|
} else if(sqlType == Types.NUMERIC || sqlType == Types.DECIMAL) {
|
|
String bigDecimalString = null;
|
|
try {
|
|
bigDecimalString = BytesToChars(OdbcApi.charSet, dataBuf);
|
|
} catch (java.io.UnsupportedEncodingException exx) {
|
|
// no action required because dataBuf is obtained from a previous CharsToBytes.
|
|
throw (Error) (new InternalError("SQL")).initCause(exx);
|
|
}
|
|
|
|
BigDecimal bd = new BigDecimal(bigDecimalString);
|
|
|
|
byte[] newDataBuf = null; // for resetting the bind buffer for the parameter number
|
|
byte[] tempBuf = null;
|
|
|
|
if(scale >= bd.scale()) {
|
|
|
|
BigDecimal bdIncreasedScale = (bd.movePointRight(scale)).movePointLeft(scale);
|
|
|
|
// fill the newDataBuf with '0'
|
|
newDataBuf = new byte[maxLen];
|
|
for(int i = 0; i < newDataBuf.length; i++) {
|
|
newDataBuf[i] = '0';
|
|
}
|
|
|
|
try {
|
|
/**
|
|
* get the byte array from the big decimal with increased scale and copy the
|
|
byte array into newDataBuf such that newDataBuf is left padded with '0' and
|
|
contains the elements in tempDataBuf towards the lower end of the array.
|
|
*/
|
|
tempBuf = CharsToBytes(OdbcApi.charSet, bdIncreasedScale.toString().toCharArray());
|
|
for(int i = newDataBuf.length - tempBuf.length; i < newDataBuf.length; i++) {
|
|
newDataBuf[i] = tempBuf[i - (newDataBuf.length - tempBuf.length)];
|
|
}
|
|
} catch (java.io.UnsupportedEncodingException exx) {
|
|
throw (Error) (new InternalError("SQL")).initCause(exx);
|
|
}
|
|
|
|
boundParams[parameterIndex - 1].resetBindDataBuffer(newDataBuf);
|
|
boundParams[parameterIndex - 1].scale = bdIncreasedScale.scale();
|
|
}
|
|
OdbcApi.SQLBindInOutParameterString (hStmt, parameterIndex, sqlType, maxLen,
|
|
boundParams[parameterIndex - 1].scale, newDataBuf, dataLen, buffers);
|
|
} else if (sqlType == OdbcDef.SQL_TIMESTAMP) {//4532162
|
|
if (boundParams[parameterIndex - 1].boundType == Types.TIMESTAMP) {
|
|
//OdbcApi.SQLBindInOutParameterTimeStamp (hStmt, parameterIndex,
|
|
//sqlType, maxLen, boundParams[parameterIndex - 1].scale,
|
|
//dataBuf, dataLen, buffers);
|
|
|
|
int scal, precision;
|
|
scal=0;precision=0;
|
|
Timestamp ts = (Timestamp)boundParams[parameterIndex - 1].boundValue;
|
|
|
|
Calendar c = Calendar.getInstance();
|
|
c.setTime(ts);
|
|
|
|
int year = c.get(Calendar.YEAR);
|
|
int month = c.get(Calendar.MONTH);
|
|
int day = c.get(Calendar.DAY_OF_MONTH);
|
|
int hour = c.get(Calendar.HOUR_OF_DAY);
|
|
int minutes = c.get(Calendar.MINUTE);
|
|
int seconds = c.get(Calendar.SECOND);
|
|
int nanos = ts.getNanos();
|
|
|
|
month = month + 1;
|
|
|
|
byte[] newDataBuf = new byte[16]; // sizeof(TIMESTAMP_STRUCT)
|
|
OdbcApi.getTimestampStruct(newDataBuf, year, month, day, hour, minutes, seconds, nanos);
|
|
|
|
boundParams[parameterIndex - 1].resetBindDataBuffer(newDataBuf);
|
|
|
|
Integer iTs = new Integer(nanos);
|
|
String sTs = iTs.toString();
|
|
|
|
char cNanos[] = sTs.toCharArray();
|
|
|
|
for (scal = cNanos.length; scal > 0; scal--){
|
|
if (cNanos[scal-1] != '0'){
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (nanos == 0) {
|
|
scal = 1;
|
|
}
|
|
|
|
precision = 20 + scal;
|
|
|
|
OdbcApi.SQLBindInOutParameterTimestamp (hStmt, parameterIndex, 29,
|
|
9, newDataBuf, dataLen, buffers);
|
|
|
|
} else {
|
|
throw new SQLException("Type mismatch between the set function and registerOutParameter");
|
|
}
|
|
} else if (sqlType == OdbcDef.SQL_DATE) {
|
|
if (boundParams[parameterIndex - 1].boundType == Types.DATE) {
|
|
//OdbcApi.SQLBindInOutParameterTimeStamp (hStmt, parameterIndex,
|
|
//sqlType, maxLen, boundParams[parameterIndex - 1].scale,
|
|
//dataBuf, dataLen, buffers);
|
|
Date d = (Date)boundParams[parameterIndex - 1].boundValue;
|
|
Calendar c = Calendar.getInstance();
|
|
c.setTime(d);
|
|
|
|
int year = c.get(Calendar.YEAR);
|
|
int month = c.get(Calendar.MONTH);
|
|
int day = c.get(Calendar.DAY_OF_MONTH);
|
|
|
|
month = month + 1;
|
|
|
|
byte[] newDataBuf = new byte[6]; // sizeof(DATE_STRUCT)
|
|
OdbcApi.getDateStruct(newDataBuf, year, month, day);
|
|
|
|
boundParams[parameterIndex - 1].resetBindDataBuffer(newDataBuf);
|
|
|
|
OdbcApi.SQLBindInOutParameterDate (hStmt, parameterIndex,
|
|
boundParams[parameterIndex - 1].scale, newDataBuf, dataLen, buffers);
|
|
|
|
} else {
|
|
throw new SQLException("Type mismatch between the set function and registerOutParameter");
|
|
}
|
|
} else if (sqlType == OdbcDef.SQL_TIME) {
|
|
if (boundParams[parameterIndex - 1].boundType == Types.TIME) {
|
|
//OdbcApi.SQLBindInOutParameterTimeStamp (hStmt, parameterIndex,
|
|
//sqlType, maxLen, boundParams[parameterIndex - 1].scale,
|
|
//dataBuf, dataLen, buffers);
|
|
Time t = (Time)boundParams[parameterIndex - 1].boundValue;
|
|
Calendar c = Calendar.getInstance();
|
|
c.setTime(t);
|
|
|
|
int hour = c.get(Calendar.HOUR_OF_DAY);
|
|
int minutes = c.get(Calendar.MINUTE);
|
|
int seconds = c.get(Calendar.SECOND);
|
|
|
|
|
|
byte[] newDataBuf = new byte[6]; // sizeof(TIME_STRUCT)
|
|
OdbcApi.getTimeStruct(newDataBuf, hour, minutes, seconds);
|
|
|
|
boundParams[parameterIndex - 1].resetBindDataBuffer(newDataBuf);
|
|
|
|
OdbcApi.SQLBindInOutParameterTime (hStmt, parameterIndex,
|
|
boundParams[parameterIndex - 1].scale, newDataBuf, dataLen, buffers);
|
|
|
|
} else {
|
|
throw new SQLException("Type mismatch between the set function and registerOutParameter");
|
|
}
|
|
} else if (sqlType == Types.LONGVARCHAR) { //4641016 - begin
|
|
if(boundParams[parameterIndex - 1].boundType == Types.LONGVARCHAR
|
|
|| boundParams[parameterIndex - 1].boundType == Types.VARCHAR
|
|
|| boundParams[parameterIndex - 1].boundType == Types.CHAR) {
|
|
|
|
if(boundParams[parameterIndex - 1].boundValue instanceof java.io.InputStream) {
|
|
byte[] newDataBuf = new byte[JdbcOdbcLimits.DEFAULT_IN_PRECISION];
|
|
for(int i = 0; i < newDataBuf.length; i++) {
|
|
newDataBuf[i] = '\0';
|
|
}
|
|
for(int i = 0; i < dataBuf.length; i++) {
|
|
newDataBuf[i] = dataBuf[i];
|
|
}
|
|
|
|
boundParams[parameterIndex - 1].resetBindDataBuffer(newDataBuf);
|
|
|
|
byte[] lenBuf = getLengthBuf (parameterIndex);
|
|
|
|
OdbcApi.SQLBindInOutParameterAtExec(hStmt, parameterIndex,
|
|
(int)OdbcDef.SQL_C_CHAR, Types.LONGVARCHAR, newDataBuf.length, newDataBuf,
|
|
boundParams[parameterIndex - 1].getInputStreamLen(), lenBuf, buffers);
|
|
} else if(boundParams[parameterIndex - 1].boundValue instanceof String) {
|
|
byte[] strBuf = null;
|
|
try {
|
|
strBuf = ((String)(boundParams[parameterIndex - 1].boundValue)).getBytes(OdbcApi.charSet);
|
|
} catch(java.io.UnsupportedEncodingException uee) {
|
|
throw new SQLException(uee.getMessage());
|
|
}
|
|
java.io.ByteArrayInputStream bais = new java.io.ByteArrayInputStream(strBuf);
|
|
boundParams[parameterIndex - 1].setInputStream(bais, strBuf.length);
|
|
|
|
byte[] newDataBuf = new byte[JdbcOdbcLimits.DEFAULT_IN_PRECISION];
|
|
for(int i = 0; i < newDataBuf.length; i++) {
|
|
newDataBuf[i] = '\0';
|
|
}
|
|
|
|
OdbcApi.intTo4Bytes(parameterIndex, newDataBuf);
|
|
|
|
boundParams[parameterIndex - 1].resetBindDataBuffer(newDataBuf);
|
|
|
|
byte[] lenBuf = getLengthBuf (parameterIndex);
|
|
|
|
OdbcApi.SQLBindInOutParameterAtExec(hStmt, parameterIndex,
|
|
(int)OdbcDef.SQL_C_CHAR, Types.LONGVARCHAR, newDataBuf.length, newDataBuf,
|
|
boundParams[parameterIndex - 1].getInputStreamLen(), lenBuf, buffers);
|
|
} else {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
} else {
|
|
throw new SQLException("Type mismatch between the set function and registerOutParameter");
|
|
}
|
|
} else if (sqlType == Types.LONGVARBINARY) { //4641016
|
|
if(boundParams[parameterIndex - 1].boundType == Types.LONGVARBINARY
|
|
|| boundParams[parameterIndex - 1].boundType == Types.VARBINARY
|
|
|| boundParams[parameterIndex - 1].boundType == Types.BINARY) {
|
|
|
|
if(boundParams[parameterIndex - 1].boundValue instanceof java.io.InputStream) {
|
|
byte[] newDataBuf = new byte[JdbcOdbcLimits.DEFAULT_IN_PRECISION];
|
|
for(int i = 0; i < newDataBuf.length; i++) {
|
|
newDataBuf[i] = '0';
|
|
}
|
|
for(int i = 0; i < dataBuf.length; i++) {
|
|
newDataBuf[i] = dataBuf[i];
|
|
}
|
|
|
|
boundParams[parameterIndex - 1].resetBindDataBuffer(newDataBuf);
|
|
|
|
byte[] lenBuf = getLengthBuf (parameterIndex);
|
|
|
|
OdbcApi.SQLBindInOutParameterAtExec(hStmt, parameterIndex,
|
|
(int)OdbcDef.SQL_C_BINARY, Types.LONGVARBINARY, newDataBuf.length, newDataBuf,
|
|
boundParams[parameterIndex - 1].getInputStreamLen(), lenBuf, buffers);
|
|
} else if(boundParams[parameterIndex - 1].boundValue instanceof byte[]) {
|
|
byte[] b = ((byte[])(boundParams[parameterIndex - 1].boundValue));
|
|
boundParams[parameterIndex - 1].setInputStream(new java.io.ByteArrayInputStream(b), b.length);
|
|
|
|
byte[] newDataBuf = new byte[JdbcOdbcLimits.DEFAULT_IN_PRECISION];
|
|
for(int i = 0; i < newDataBuf.length; i++) {
|
|
newDataBuf[i] = '0';
|
|
}
|
|
|
|
OdbcApi.intTo4Bytes(parameterIndex, newDataBuf);
|
|
|
|
boundParams[parameterIndex - 1].resetBindDataBuffer(newDataBuf);
|
|
|
|
byte[] lenBuf = getLengthBuf (parameterIndex);
|
|
|
|
OdbcApi.SQLBindInOutParameterAtExec(hStmt, parameterIndex,
|
|
(int)OdbcDef.SQL_C_BINARY, Types.LONGVARBINARY, newDataBuf.length, newDataBuf,
|
|
boundParams[parameterIndex - 1].getInputStreamLen(), lenBuf, buffers);
|
|
|
|
} else {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
} else {
|
|
throw new SQLException("Type mismatch between the set function and registerOutParameter");
|
|
} // 4641016 - end
|
|
} else {
|
|
throw new UnsupportedOperationException();
|
|
} // bug 4412437 - end
|
|
} else { // if out parameter
|
|
// check if maxLen is 8000(i.e DEFAULT)
|
|
// Modify maxLen to be appropriate value it should be.
|
|
if (sqlType == Types.NULL ) { //4532162
|
|
OdbcApi.SQLBindOutParameterNull (hStmt, parameterIndex,
|
|
sqlType, maxLen, boundParams[parameterIndex - 1].scale,
|
|
dataLen, buffers);
|
|
}
|
|
else if (sqlType == Types.DOUBLE || sqlType == Types.FLOAT || sqlType == Types.REAL) { //4532162
|
|
OdbcApi.SQLBindOutParameterFixed (hStmt, parameterIndex,
|
|
Types.DOUBLE, maxLen, dataBuf, dataLen, buffers);
|
|
}
|
|
else if (sqlType == Types.INTEGER) { //4532162
|
|
OdbcApi.SQLBindOutParameterFixed (hStmt, parameterIndex,
|
|
sqlType, maxLen, dataBuf, dataLen, buffers);
|
|
}
|
|
else if (sqlType == Types.TINYINT) { //4532162
|
|
OdbcApi.SQLBindOutParameterFixed (hStmt, parameterIndex,
|
|
sqlType, maxLen, dataBuf, dataLen, buffers);
|
|
}
|
|
else if (sqlType == Types.SMALLINT) { //4532162
|
|
OdbcApi.SQLBindOutParameterFixed (hStmt, parameterIndex,
|
|
sqlType, maxLen, dataBuf, dataLen, buffers);
|
|
}
|
|
else if (sqlType == Types.BIT) { //4532162
|
|
OdbcApi.SQLBindOutParameterFixed (hStmt, parameterIndex,
|
|
sqlType, 1, dataBuf, dataLen, buffers);
|
|
}
|
|
else if (sqlType == Types.BIGINT) { //4532162
|
|
OdbcApi.SQLBindOutParameterFixed (hStmt, parameterIndex,
|
|
sqlType, maxLen, dataBuf, dataLen, buffers);
|
|
}
|
|
else if(sqlType == Types.NUMERIC || sqlType == Types.DECIMAL) {//4532162
|
|
//4709519
|
|
//changing boundParams[parameterIndex - 1].scale to scale
|
|
OdbcApi.SQLBindOutParameterString (hStmt, parameterIndex, sqlType,
|
|
scale, dataBuf, dataLen, buffers);
|
|
}
|
|
else if (sqlType == OdbcDef.SQL_TIMESTAMP) { //4532162
|
|
OdbcApi.SQLBindOutParameterTimestamp (hStmt, parameterIndex,
|
|
maxLen, dataBuf, dataLen, buffers);
|
|
}
|
|
else if (sqlType == OdbcDef.SQL_DATE) {//4532162
|
|
OdbcApi.SQLBindOutParameterDate (hStmt, parameterIndex,
|
|
boundParams[parameterIndex - 1].scale, dataBuf, dataLen, buffers);
|
|
}
|
|
else if (sqlType == OdbcDef.SQL_TIME) {//4532162
|
|
OdbcApi.SQLBindOutParameterTime (hStmt, parameterIndex,
|
|
boundParams[parameterIndex - 1].scale, dataBuf, dataLen, buffers);
|
|
}
|
|
else if(sqlType == Types.BINARY || sqlType == Types.VARBINARY || sqlType == Types.LONGVARBINARY) {//4532162
|
|
OdbcApi.SQLBindOutParameterBinary(hStmt, parameterIndex, sqlType,
|
|
maxLen, scale, dataBuf, dataLen, buffers);
|
|
|
|
}
|
|
else if(sqlType == Types.CHAR || sqlType == Types.VARCHAR || sqlType == Types.LONGVARCHAR) {//4532162
|
|
OdbcApi.SQLBindOutParameterString (hStmt, parameterIndex,
|
|
sqlType, scale, dataBuf, dataLen, buffers);
|
|
}
|
|
else {//4532162
|
|
OdbcApi.SQLBindOutParameterString (hStmt, parameterIndex,
|
|
sqlType, scale, dataBuf, dataLen, buffers);
|
|
|
|
}
|
|
} //if OutParameter
|
|
|
|
//save the native pointers from garbage collection
|
|
boundParams[parameterIndex - 1].pA1=buffers[0];
|
|
boundParams[parameterIndex - 1].pA2=buffers[1];
|
|
boundParams[parameterIndex - 1].pB1=buffers[2];
|
|
boundParams[parameterIndex - 1].pB2=buffers[3];
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
// wasNull
|
|
// An OUT parameter may have the value of SQL NULL; wasNull reports
|
|
// whether the last value read has this special value.
|
|
//--------------------------------------------------------------------
|
|
|
|
public boolean wasNull ()
|
|
throws SQLException
|
|
{
|
|
return lastParameterNull;
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
// getString
|
|
//--------------------------------------------------------------------
|
|
|
|
public String getString (
|
|
int parameterIndex)
|
|
throws SQLException
|
|
{
|
|
// If the value is null, return a null object
|
|
if (isNull (parameterIndex)) {
|
|
return null;
|
|
}
|
|
|
|
// Get the SQL type of the parameter
|
|
|
|
int sqlType = getSqlType (parameterIndex);
|
|
|
|
// Convert the data buffer for the output parameter into
|
|
// a String
|
|
String s=null;
|
|
try
|
|
{
|
|
byte[] bindBuf = getDataBuf(parameterIndex);
|
|
if (bindBuf != null)
|
|
{
|
|
s = BytesToChars (OdbcApi.charSet, bindBuf);
|
|
}
|
|
}
|
|
catch (java.io.UnsupportedEncodingException exx) {
|
|
throw (Error) (new InternalError("SQL")).initCause(exx);
|
|
}
|
|
// Remove trailing spaces
|
|
|
|
//s = s.trim ();
|
|
|
|
if (OdbcApi.getTracer().isTracing ()) {
|
|
OdbcApi.getTracer().trace ("String value for OUT parameter " +
|
|
parameterIndex + "=" + s);
|
|
}
|
|
return s;
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
// Since the output parameter was bound as a specific C type
|
|
// (always a SQL_C_CHAR), we will have to get the output parameter
|
|
// as a character, then convert it to the proper return type.
|
|
//--------------------------------------------------------------------
|
|
|
|
//--------------------------------------------------------------------
|
|
// getBoolean
|
|
//--------------------------------------------------------------------
|
|
|
|
public boolean getBoolean (
|
|
int parameterIndex)
|
|
throws SQLException
|
|
{
|
|
// If the value is null, return false
|
|
if (isNull (parameterIndex)) {
|
|
return false;
|
|
}
|
|
|
|
//4532162
|
|
if(getInt(parameterIndex) == 1)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
// getByte
|
|
//--------------------------------------------------------------------
|
|
|
|
public byte getByte (
|
|
int parameterIndex)
|
|
throws SQLException
|
|
{
|
|
// Cast getInt to a byte value
|
|
//4532162
|
|
return (byte) getInt (parameterIndex);
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
// getShort
|
|
//--------------------------------------------------------------------
|
|
|
|
public short getShort (
|
|
int parameterIndex)
|
|
throws SQLException
|
|
{
|
|
// Cast getInt to a short value
|
|
//4532162
|
|
return (short) getInt (parameterIndex);
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
// getInt
|
|
//--------------------------------------------------------------------
|
|
|
|
public int getInt (
|
|
int parameterIndex)
|
|
throws SQLException
|
|
{
|
|
// If the value is null, return zero
|
|
if (isNull (parameterIndex)) {
|
|
return 0;
|
|
}
|
|
|
|
// bug 4412437 //4532162
|
|
return OdbcApi.bufferToInt(getDataBuf(parameterIndex));
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
// getLong
|
|
//--------------------------------------------------------------------
|
|
|
|
public long getLong (
|
|
int parameterIndex)
|
|
throws SQLException
|
|
{
|
|
// If the value is null, return zero
|
|
if (isNull (parameterIndex)) {
|
|
return 0;
|
|
}
|
|
//4532162
|
|
// Create a Long object from the output parameter string
|
|
return OdbcApi.bufferToLong(getDataBuf(parameterIndex));
|
|
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
// getFloat
|
|
//--------------------------------------------------------------------
|
|
|
|
public float getFloat (
|
|
int parameterIndex)
|
|
throws SQLException
|
|
{
|
|
// If the value is null, return zero
|
|
if (isNull (parameterIndex)) {
|
|
return 0;
|
|
}
|
|
|
|
// Fix 4532167. using bufferToDouble to get even the minimum value of java
|
|
return (float) OdbcApi.bufferToDouble(getDataBuf(parameterIndex));
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
// getDouble
|
|
//--------------------------------------------------------------------
|
|
|
|
public double getDouble (
|
|
int parameterIndex)
|
|
throws SQLException
|
|
{
|
|
// If the value is null, return zero
|
|
if (isNull (parameterIndex)) {
|
|
return 0;
|
|
}
|
|
|
|
// bug 4412437 //4532162
|
|
return OdbcApi.bufferToDouble(getDataBuf(parameterIndex));
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
// getBigDecimal
|
|
//--------------------------------------------------------------------
|
|
|
|
public BigDecimal getBigDecimal (
|
|
int parameterIndex,
|
|
int scale)
|
|
throws SQLException
|
|
{
|
|
// If the value is null, return null
|
|
if (isNull (parameterIndex)) {
|
|
return null;
|
|
}
|
|
// Create a BigDecimal object from the output parameter string
|
|
BigDecimal num = new BigDecimal(getString (parameterIndex).trim());
|
|
/* NOTE: In the old-style Bignum there was the notion of
|
|
a default rounding mode. There is no longer this
|
|
notion, and so we default to something reasonable. */
|
|
return num.setScale(scale, BigDecimal.ROUND_HALF_EVEN);
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
// getBytes
|
|
// Returns a byte array of the bound parameter data.
|
|
//--------------------------------------------------------------------
|
|
|
|
public byte[] getBytes (
|
|
int parameterIndex)
|
|
throws SQLException
|
|
{
|
|
// If the value is null, return null
|
|
if (isNull (parameterIndex)) {
|
|
return null;
|
|
}
|
|
|
|
if (boundParams[parameterIndex-1].isInOutParameter() || boundParams[parameterIndex-1].isOutputParameter() )
|
|
{
|
|
//4532162
|
|
int paramLength = getParamLength(parameterIndex);
|
|
byte[] bindBuf = getDataBuf(parameterIndex);
|
|
if (paramLength < bindBuf.length)
|
|
{
|
|
byte[] outBuf = new byte[paramLength];
|
|
for (int i=0; i<getParamLength(parameterIndex); i++)
|
|
outBuf[i] = bindBuf[i];
|
|
boundParams[parameterIndex-1].resetBindDataBuffer(outBuf);
|
|
return outBuf;
|
|
}
|
|
return bindBuf;
|
|
}
|
|
// Convert the bound character string (in hexadecimal)
|
|
// into a byte array
|
|
return hexStringToByteArray (getString (parameterIndex).trim());
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
// getDate
|
|
//--------------------------------------------------------------------
|
|
|
|
public java.sql.Date getDate (
|
|
int parameterIndex)
|
|
throws SQLException
|
|
{
|
|
|
|
// If the value is null, return null
|
|
if (isNull (parameterIndex)) {
|
|
return null;
|
|
}
|
|
|
|
//4532162
|
|
byte[] dataBuf = getDataBuf(parameterIndex);
|
|
byte[] dateString = new byte[11];
|
|
|
|
OdbcApi.convertDateString(dataBuf, dateString);
|
|
return java.sql.Date.valueOf((new String(dateString)).trim());
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
// getTime
|
|
//--------------------------------------------------------------------
|
|
|
|
public java.sql.Time getTime (
|
|
int parameterIndex)
|
|
throws SQLException
|
|
{
|
|
// If the value is null, return zero
|
|
if (isNull (parameterIndex)) {
|
|
return null;
|
|
}
|
|
//4532162
|
|
byte[] dataBuf = getDataBuf(parameterIndex);
|
|
byte[] timeString = new byte[9];
|
|
|
|
OdbcApi.convertTimeString(dataBuf, timeString);
|
|
return java.sql.Time.valueOf((new String(timeString)).trim());
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
// getTimestamp
|
|
//--------------------------------------------------------------------
|
|
|
|
public java.sql.Timestamp getTimestamp (
|
|
int parameterIndex)
|
|
throws SQLException
|
|
{
|
|
if (isNull (parameterIndex)) {
|
|
return null;
|
|
}
|
|
//4532162
|
|
byte[] dataBuf = getDataBuf(parameterIndex);
|
|
byte[] timestampString = new byte[30];
|
|
|
|
OdbcApi.convertTimestampString(dataBuf, timestampString);
|
|
return java.sql.Timestamp.valueOf((new String(timestampString)).trim());
|
|
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------
|
|
// getObject
|
|
// Returns a Java object for the parameter.
|
|
// See the JDBC spec's "Dynamic Programming" chapter for details.
|
|
//--------------------------------------------------------------------
|
|
|
|
public Object getObject (
|
|
int parameterIndex)
|
|
throws SQLException
|
|
{
|
|
Object value = null;
|
|
|
|
// Get the SQL type of the parameter
|
|
int sqlType = getSqlType (parameterIndex);
|
|
|
|
// If the column is null, always return a null object
|
|
if (isNull (parameterIndex)) {
|
|
return null;
|
|
}
|
|
|
|
// For each SQL type, call the appropriate routine and
|
|
// convert to the proper object type
|
|
|
|
switch (sqlType) {
|
|
|
|
case Types.CHAR:
|
|
case Types.VARCHAR:
|
|
case Types.LONGVARCHAR:
|
|
|
|
// // Get the data as a string, convert it to a byte
|
|
// // array, and return an InputStream
|
|
//
|
|
// String s = getLongVarChar (parameterIndex);
|
|
// if (s != null) {
|
|
// byte b[] = new byte[s.length ()];
|
|
// s.getBytes (0, s.length (), b, 0);
|
|
// value = (Object) new JdbcOdbcInputStream (
|
|
// OdbcApi, hStmt, parameterIndex, b);
|
|
// }
|
|
|
|
value = (Object) getString (parameterIndex);
|
|
break;
|
|
|
|
case Types.NUMERIC:
|
|
case Types.DECIMAL:
|
|
|
|
// The getNumeric method requires us to provide
|
|
// a scale. The only way to get the scale is to
|
|
// call DatabaseMetaData.getProcedureColumns
|
|
// (which may not be supported for the data source)
|
|
// We'll use the scale stored in scalez[]
|
|
if (parameterIndex<=200)
|
|
value = (Object) getBigDecimal(parameterIndex, scalez[parameterIndex]);
|
|
else
|
|
value = (Object) getBigDecimal(parameterIndex, JdbcOdbcLimits.DEFAULT_OUT_SCALE);
|
|
break;
|
|
|
|
case Types.BIT:
|
|
value = (Object) new Boolean (
|
|
getBoolean (parameterIndex));
|
|
break;
|
|
|
|
case Types.TINYINT:
|
|
value = (Object) new Integer (getByte (
|
|
parameterIndex));
|
|
break;
|
|
|
|
case Types.SMALLINT:
|
|
value = (Object) new Integer (getShort (
|
|
parameterIndex));
|
|
break;
|
|
|
|
case Types.INTEGER:
|
|
value = (Object) new Integer (getInt (
|
|
parameterIndex));
|
|
break;
|
|
|
|
case Types.BIGINT:
|
|
value = (Object) new Long (getLong (parameterIndex));
|
|
break;
|
|
|
|
case Types.REAL:
|
|
value = (Object) new Float (getFloat (parameterIndex));
|
|
break;
|
|
//4532167
|
|
case Types.FLOAT:
|
|
case Types.DOUBLE:
|
|
value = (Object) new Double (getDouble (
|
|
parameterIndex));
|
|
break;
|
|
|
|
case Types.BINARY:
|
|
case Types.VARBINARY:
|
|
case Types.LONGVARBINARY:
|
|
|
|
// // Get the data as a byte array and convert to an
|
|
// // InputStream
|
|
//
|
|
// byte b[] = getLongVarBinary (parameterIndex);
|
|
// if (b != null) {
|
|
// value = (Object) new JdbcOdbcInputStream (
|
|
// OdbcApi, hStmt, parameterIndex, b);
|
|
// }
|
|
value = (Object) getBytes (parameterIndex);
|
|
break;
|
|
|
|
case Types.DATE:
|
|
value = (Object) getDate (parameterIndex);
|
|
break;
|
|
|
|
case Types.TIME:
|
|
value = (Object) getTime (parameterIndex);
|
|
break;
|
|
|
|
case Types.TIMESTAMP:
|
|
value = (Object) getTimestamp (parameterIndex);
|
|
break;
|
|
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
|
|
// New JDBC 2.0 API
|
|
|
|
public BigDecimal getBigDecimal (
|
|
int parameterIndex)
|
|
throws SQLException
|
|
{
|
|
// If the value is null, return null
|
|
if (isNull (parameterIndex))
|
|
{
|
|
return null;
|
|
}
|
|
// Create a BigDecimal object from the output parameter string
|
|
BigDecimal num = new BigDecimal(getString (parameterIndex).trim());
|
|
|
|
/* NOTE: for 2.0 version the decimal value return a full precision.
|
|
no scale is specified. */
|
|
|
|
return num;
|
|
}
|
|
|
|
|
|
public Object getObject (
|
|
int i,
|
|
Map map)
|
|
throws SQLException
|
|
{ return null; }
|
|
|
|
public Ref getRef (
|
|
int i)
|
|
throws SQLException
|
|
{ return null; }
|
|
|
|
public Blob getBlob (
|
|
int i)
|
|
throws SQLException
|
|
{ return null; }
|
|
|
|
public Clob getClob (
|
|
int i)
|
|
throws SQLException
|
|
{ return null; }
|
|
|
|
public Array getArray (
|
|
int i)
|
|
throws SQLException
|
|
{ return null; }
|
|
|
|
public Date getDate (
|
|
int parameterIndex,
|
|
Calendar cal)
|
|
throws SQLException
|
|
{
|
|
long lValue = 0L;
|
|
//4532162
|
|
//store date vaue in a java.sql.Date value
|
|
if (getDate(parameterIndex) == null){
|
|
return null;
|
|
}
|
|
else if (getDate(parameterIndex) != null){
|
|
// Fix 4380653.
|
|
lValue = utils.convertFromGMT(getDate(parameterIndex) , cal);
|
|
}
|
|
|
|
if (lValue == 0L){
|
|
return null;
|
|
}
|
|
else
|
|
return new java.sql.Date(lValue);
|
|
}
|
|
|
|
public Time getTime (
|
|
int parameterIndex,
|
|
Calendar cal)
|
|
throws SQLException
|
|
{
|
|
long lValue = 0L;
|
|
//4532162
|
|
if ( getTime(parameterIndex) == null) {
|
|
return null;
|
|
}
|
|
else if (getTime(parameterIndex) != null){
|
|
try{
|
|
// Fix 4389653
|
|
lValue = utils.convertFromGMT(getTime(parameterIndex), cal);
|
|
}catch (Exception te){}
|
|
}
|
|
|
|
if (lValue == 0L){
|
|
return null;
|
|
}
|
|
else
|
|
return new java.sql.Time(lValue);
|
|
|
|
}
|
|
|
|
public Timestamp getTimestamp (
|
|
int parameterIndex,
|
|
Calendar cal)
|
|
throws SQLException
|
|
{
|
|
long lValue = 0L;
|
|
//4532162
|
|
if ( (getTimestamp (parameterIndex)) == null){
|
|
return null;
|
|
}
|
|
|
|
try{
|
|
// Fix 4380653
|
|
lValue = utils.convertFromGMT(getTimestamp (parameterIndex), cal);
|
|
}catch (Exception te){}
|
|
|
|
if (lValue == 0L){
|
|
return null;
|
|
}
|
|
else
|
|
return new java.sql.Timestamp(lValue);
|
|
}
|
|
|
|
public void registerOutParameter (
|
|
int paramIndex,
|
|
int sqlType,
|
|
String typeName)
|
|
throws SQLException
|
|
{ //4532162
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
// isNull
|
|
// Helper method to determine if an output parameter is null. Also
|
|
// sets the lastParameterNull attribute for use with wasNull.
|
|
//--------------------------------------------------------------------
|
|
|
|
protected boolean isNull (
|
|
int parameterIndex)
|
|
throws SQLException
|
|
{
|
|
// Verify that the given parameter is for OUTPUT
|
|
|
|
if (!isOutputParameter (parameterIndex)) {
|
|
throw new SQLException ("Parameter " + parameterIndex +
|
|
" is not an OUTPUT parameter");
|
|
}
|
|
|
|
boolean rc = false;
|
|
rc = (getParamLength(parameterIndex) == OdbcDef.SQL_NULL_DATA);
|
|
if (OdbcApi.getTracer().isTracing ()) {
|
|
OdbcApi.getTracer().trace ("Output Parameter " + parameterIndex +
|
|
" null: " + rc);
|
|
}
|
|
lastParameterNull = rc;
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
//THIS MAY NEED TO BE MOVE TO JdbcOdbcPreparedStatement class!!
|
|
// now also used by executeBatchUpdate for PreparedStatement.
|
|
//--------------------------------------------------------------------
|
|
// setSqlType
|
|
// Sets the Java sql type for when registering an OUT parameter
|
|
//--------------------------------------------------------------------
|
|
|
|
protected void setSqlType (
|
|
int index,
|
|
int type)
|
|
{
|
|
// Sanity check the parameter number
|
|
|
|
if ((index >= 1) &&
|
|
(index <= numParams)) {
|
|
boundParams[index - 1].setSqlType (type);
|
|
}
|
|
}
|
|
|
|
|
|
//THIS MAY NEED TO BE MOVE TO JdbcOdbcPreparedStatement class!!
|
|
// now also used by executeBatchUpdate for PreparedStatement.
|
|
//--------------------------------------------------------------------
|
|
// getSqlType
|
|
// Gets the Java sql type for when registering an OUT parameter
|
|
//--------------------------------------------------------------------
|
|
|
|
protected int getSqlType (
|
|
int index)
|
|
{
|
|
int type = Types.OTHER;
|
|
|
|
// Sanity check the parameter number
|
|
|
|
if ((index >= 1) &&
|
|
(index <= numParams)) {
|
|
type = boundParams[index - 1].getSqlType ();
|
|
}
|
|
return type;
|
|
}
|
|
*/
|
|
|
|
//--------------------------------------------------------------------
|
|
// setOutputParameter
|
|
// Sets the output parameter flag
|
|
//--------------------------------------------------------------------
|
|
|
|
protected void setOutputParameter (
|
|
int index,
|
|
boolean output)
|
|
{
|
|
// Sanity check the parameter number
|
|
|
|
if ((index >= 1) &&
|
|
(index <= numParams)) {
|
|
boundParams[index - 1].setOutputParameter (output);
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
// isOutputParameter
|
|
// Returns true if the given parameter is for OUTPUT
|
|
//--------------------------------------------------------------------
|
|
|
|
protected boolean isOutputParameter (
|
|
int index)
|
|
{
|
|
boolean output = false;
|
|
|
|
// Sanity check the parameter number
|
|
|
|
if ((index >= 1) &&
|
|
(index <= numParams)) {
|
|
output = boundParams[index - 1].isOutputParameter ();
|
|
}
|
|
return output;
|
|
}
|
|
|
|
|
|
|
|
public synchronized void close ()
|
|
throws SQLException
|
|
{
|
|
if (OdbcApi.getTracer().isTracing ()) {
|
|
OdbcApi.getTracer().trace ("*Statement.close");
|
|
}
|
|
|
|
// Close/clear our result set
|
|
|
|
clearMyResultSet ();
|
|
|
|
// Reset last warning message
|
|
|
|
try {
|
|
clearWarnings ();
|
|
if (hStmt != OdbcDef.SQL_NULL_HSTMT) {
|
|
//4524683
|
|
if(closeCalledFromFinalize == true) {
|
|
if( myConnection.isFreeStmtsFromConnectionOnly() == false) {
|
|
OdbcApi.SQLFreeStmt (hStmt, OdbcDef.SQL_DROP);
|
|
}
|
|
}
|
|
else {
|
|
OdbcApi.SQLFreeStmt (hStmt, OdbcDef.SQL_DROP);
|
|
}
|
|
hStmt = OdbcDef.SQL_NULL_HSTMT;
|
|
FreeParams();
|
|
for (int pindex=1; boundParams != null && pindex <= boundParams.length; pindex++)
|
|
{
|
|
boundParams[pindex-1].binaryData = null;
|
|
boundParams[pindex-1].initialize ();
|
|
boundParams[pindex-1].paramInputStream = null;
|
|
boundParams[pindex-1].inputParameter = false;
|
|
}
|
|
}
|
|
}
|
|
catch (SQLException ex) {
|
|
// If we get an error, ignore
|
|
}
|
|
|
|
// Remove this Statement object from the Connection object's
|
|
// list
|
|
|
|
myConnection.deregisterStatement (this);
|
|
}
|
|
|
|
public synchronized void FreeParams()
|
|
throws NullPointerException
|
|
{
|
|
try {
|
|
for (int pindex=1; pindex <= boundParams.length; pindex++)
|
|
{
|
|
if (boundParams[pindex-1].pA1!=0)
|
|
{
|
|
OdbcApi.ReleaseStoredBytes (boundParams[pindex-1].pA1, boundParams[pindex-1].pA2);
|
|
boundParams[pindex-1].pA1=0;
|
|
boundParams[pindex-1].pA2=0;
|
|
}
|
|
if (boundParams[pindex-1].pB1!=0)
|
|
{
|
|
OdbcApi.ReleaseStoredBytes (boundParams[pindex-1].pB1, boundParams[pindex-1].pB2);
|
|
boundParams[pindex-1].pB1=0;
|
|
boundParams[pindex-1].pB2=0;
|
|
}
|
|
if (boundParams[pindex-1].pC1!=0)
|
|
{
|
|
OdbcApi.ReleaseStoredBytes (boundParams[pindex-1].pC1, boundParams[pindex-1].pC2);
|
|
boundParams[pindex-1].pC1=0;
|
|
boundParams[pindex-1].pC2=0;
|
|
}
|
|
if (boundParams[pindex-1].pS1!=0)
|
|
{
|
|
OdbcApi.ReleaseStoredChars (boundParams[pindex-1].pS1, boundParams[pindex-1].pS2);
|
|
boundParams[pindex-1].pS1=0;
|
|
boundParams[pindex-1].pS2=0;
|
|
}
|
|
}
|
|
}
|
|
catch (NullPointerException npx)
|
|
{
|
|
//Do nothing
|
|
}
|
|
}//FreeParams
|
|
|
|
//----------------------------------------------------------------
|
|
// JDBC 3.0 API Changes
|
|
//----------------------------------------------------------------
|
|
|
|
|
|
public java.net.URL getURL(int parameterIndex) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public void setURL(String parameterName, java.net.URL val) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public void setNull(String parameterName, int sqlType) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public void setBoolean(String parameterName, boolean x) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
|
|
|
|
public void setByte(String parameterName, byte x) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public void setShort(String parameterName, short x) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public void setInt(String parameterName, int x) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public void setLong(String parameterName, long x) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public void setFloat(String parameterName, float x) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public void setDouble(String parameterName, double x) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public void setBigDecimal(String parameterName, BigDecimal x) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public void setString(String parameterName, String x) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public void setBytes(String parameterName, byte x[]) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public void setDate(String parameterName, java.sql.Date x)
|
|
throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public void setTime(String parameterName, java.sql.Time x)
|
|
throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public void setTimestamp(String parameterName, java.sql.Timestamp x)
|
|
throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public void setAsciiStream(String parameterName, java.io.InputStream x, int length)
|
|
throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public void setBinaryStream(String parameterName, java.io.InputStream x,
|
|
int length) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public void setObject(String parameterName, Object x, int targetSqlType, int scale)
|
|
throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public void setObject(String parameterName, Object x, int targetSqlType)
|
|
throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public void setObject(String parameterName, Object x) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public void setCharacterStream(String parameterName,
|
|
java.io.Reader reader,
|
|
int length) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public void setDate(String parameterName, java.sql.Date x, Calendar cal)
|
|
throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public void setTime(String parameterName, java.sql.Time x, Calendar cal)
|
|
throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public void setTimestamp(String parameterName, java.sql.Timestamp x, Calendar cal)
|
|
throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public void setNull (String parameterName, int sqlType, String typeName)
|
|
throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public void registerOutParameter(String parameterName, int sqlType)
|
|
throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public void registerOutParameter(String parameterName, int sqlType, int scale)
|
|
throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public void registerOutParameter (String parameterName, int sqlType, String typeName)
|
|
throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public String getString(String parameterName) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public boolean getBoolean(String parameterName) throws SQLException{
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public byte getByte(String parameterName) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public short getShort(String parameterName) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public int getInt(String parameterName) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public long getLong(String parameterString) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public float getFloat(String parameterName) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public double getDouble(String parameterName) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public byte[] getBytes(String parameterName) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public java.sql.Date getDate(String parameterName) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public java.sql.Time getTime(String parameterName) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public java.sql.Timestamp getTimestamp(String parameterName) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public Object getObject(String parameterName) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public BigDecimal getBigDecimal(String parameterName) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public Object getObject (String parameterName, java.util.Map map) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public Ref getRef (String ParameterName) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public Blob getBlob (String parameterName) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public Clob getClob (String parameterName) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public Array getArray (String parameterName) throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public java.sql.Date getDate(String parameterName, Calendar cal)
|
|
throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public java.sql.Time getTime(String parameterName, Calendar cal)
|
|
throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public java.sql.Timestamp getTimestamp(String parameterName, Calendar cal)
|
|
throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public java.net.URL getURL(String parameterName)
|
|
throws SQLException {
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
|
|
//====================================================================
|
|
// Data attributes
|
|
//====================================================================
|
|
|
|
private boolean lastParameterNull; // true if the last parameter
|
|
// referenced by a getXXX
|
|
// function was null
|
|
|
|
}
|