true, the data of the
* existing Parseinfo structure shall be overwritten.
* @return the Parseinfo produced.
* @exception java.sql.SQLException The exception description.
*/
private Parseinfo doParse (String sql,
boolean parseAgain)
throws SQLException
{
if (sql == null) {
throw new SQLExceptionSapDB(MessageTranslator.translate
(MessageKey.ERROR_SQLSTATEMENT_NULL),
"42000");
}
ReplyPacket replyPacket;
PartEnumeration enume;
Parseinfo result = null;
ParseinfoCache cache = this.connection.parseCache;
String[] columnNames = null;
if (sql == null)
throw new SQLExceptionSapDB("SQL statement is null","42000");
this.fetchInfo = null;
if (parseAgain) {
result = this.parseinfo;
result.setMassParseid(null);
}
else if (cache != null) {
result = cache.findParseinfo (sql);
}
if ((result == null) || parseAgain) {
/*
* exceute SQL
*/
// boolean backupWithInfo=setWithInfo;
// !!! withinfo flag is not set as it may cause a crash !!!
try {
setWithInfo=true;
replyPacket = this.sendSQL (sql, this.resultSetType, this.resultSetConcurrency, parseAgain);
} catch(com.sap.dbtech.jdbc.exceptions.TimeoutException exc){
if (this.statementType == Statement_UpdatableResultSet){
this.connection.close();
throw exc;
}
replyPacket = this.sendSQL (sql, this.resultSetType, this.resultSetConcurrency, parseAgain);
}
// finally {
// setWithInfo=backupWithInfo;
// }
/*
* parse result
*/
if (!parseAgain) {
result = new Parseinfo (this.connection, sql, replyPacket.functionCode ());
}
enume = replyPacket.partEnumeration ();
DBTechTranslator shortInfos[] = null;
while (enume.hasMoreElements ()) {
enume.nextElement ();
switch (enume.partKind ()) {
case PartKind.Parsid_C:
int parseidPos = replyPacket.getPartDataPos ();
result.setParseIdAndSession(replyPacket.getBytes (parseidPos, 12),
replyPacket.getInt4 (parseidPos));
break;
case PartKind.Shortinfo_C:
shortInfos=replyPacket.parseShortFields(this.connection.isSpaceoptionSet,
result.isDBProc,
result.procParamInfos, false);
break;
case PartKind.Vardata_Shortinfo_C:
result.varDataInput = true;
shortInfos=replyPacket.parseShortFields(this.connection.isSpaceoptionSet,
result.isDBProc,
result.procParamInfos, true);
break;
case PartKind.Resulttablename_C:
result.setSelect(true);
int cursorLength = replyPacket.partLength ();
if (cursorLength > 0) {
this.cursorName = replyPacket.getString (replyPacket.getPartDataPos (), cursorLength);
}
break;
case PartKind.Tablename_C:
result.setUpdateTableName(replyPacket.getString (replyPacket.getPartDataPos (), replyPacket.partLength ()));
break;
case PartKind.Columnnames_C:
columnNames = replyPacket.parseColumnNames ();
break;
default:
// this.addWarning(new SQLWarning
// (MessageTranslator.translate
// (MessageKey.WARNING_PART_NOTHANDLED,
// PartKind.names[enume.partKind()]))
// );
break;
}
}
result.setShortInfosAndColumnNames(shortInfos, columnNames);
if ((cache != null) && !parseAgain) {
cache.addParseinfo (result);
}
}
this.inputArgs = new Object [result.paramInfos.length];
this.clearParameters();
return result;
}
/**
* execute method comment.
*/
public boolean execute()
throws java.sql.SQLException
{
this.assertOpen ();
return this.execute (maxParseAgainCnt);
}
/**
*
*/
private void
reparse ()
throws java.sql.SQLException
{
Object [] tmpArgs = this.inputArgs;
this.doParse (this.parseinfo.sqlCmd, true);
this.inputArgs = tmpArgs;
}
/**
*
*/
protected String getUpdTablename(String sqlCmd) {
return this.parseinfo.updTableName;
}
/**
* execute method comment.
*/
public boolean execute(int afterParseAgain)
throws SQLException
{
if (this.connection == null) {
throw new InternalJDBCError(MessageTranslator.translate(MessageKey.ERROR_INTERNAL_CONNECTIONNULL));
}
RequestPacket requestPacket;
ReplyPacket replyPacket;
boolean isQuery;
DataPart dataPart;
// if this is one of the statements that is executed
// during parse instead of execution, execute it
// by doing a reparse
if(this.parseinfo.isAlreadyExecuted()) {
this.replyMem = null;
this.closeResultSet (true);
if (this.connection == null) {
throw new NullPointerException ();
}
this.reparse();
this.rowsAffected=0;
return false;
}
if (! this.parseinfo.isValid ()) {
this.reparse ();
}
try {
this.canceled = false;
this.closeResultSet(true);
// check if a reparse is needed.
if (!this.parseinfo.isValid ()) {
this.reparse ();
}
this.replyMem = null;
this.outputOMSStreams = null;
requestPacket = this.connection.getRequestPacket (this.packetEncodingUnicode);
requestPacket.initExecute (this.parseinfo.getParseId(),
this.connection.autocommit,
this.resultSetType);
if (this.parseinfo.isSelect) {
requestPacket.addCursorPart (this.cursorName);
}
// We must add a data part if we have input parameters or even if
// we have output streams.
if (this.parseinfo.inputCount > 0 || this.parseinfo.hasStreams) {
dataPart = requestPacket.newDataPart(this.parseinfo.varDataInput);
if (this.parseinfo.inputCount > 0) {
dataPart.addRow(this.parseinfo.inputCount);
for (int i = 0; i < this.parseinfo.paramInfos.length; ++i) {
if (this.parseinfo.paramInfos[i].isInput()
&& initialParamValue == this.inputArgs[i]) {
if (this.parseinfo.paramInfos[i].isStreamKind()
&& this.outPutTypes != null
&& this.outPutTypes[i + 1] != 0) {
if (this.outputOMSStreams == null) {
this.outputOMSStreams = new Vector();
}
ABAPStreamTranslator t = (ABAPStreamTranslator) this.parseinfo.paramInfos[i];
AbstractABAPStreamGetval getval = t
.createGetval();
outputOMSStreams.add(getval);
t.put(dataPart, getval);
} else {
throw new SQLException(MessageTranslator
.translate(
MessageKey.ERROR_MISSINGINOUT,
Integer.toString(i + 1)),
"02000");
}
} else {
this.parseinfo.paramInfos[i].put(dataPart,
this.inputArgs[i]);
}
}
this.inputProcedureLongs = null;
if (this.parseinfo.hasLongs) {
if (this.parseinfo.isDBProc) {
this.handleProcedureStreamsForExecute(dataPart,
this.inputArgs);
} else {
this.handleStreamsForExecute(dataPart,
this.inputArgs);
}
}
if (this.parseinfo.hasStreams) {
this.handleOMSStreamsForExecute(dataPart);
}
} else {
// we have only streams
this.handleOMSStreamsForExecute(dataPart);
}
dataPart.close();
}
/*add a decribe order if command rturns a resultset*/
if ( this.parseinfo.isSelect
&&this.parseinfo.columnInfos == null
&&this.parseinfo.functionCode != FunctionCode.DBProcWithResultSetExecute_FC ){
requestPacket.initDbsCommand("DESCRIBE ",false, false, ResultSet.TYPE_FORWARD_ONLY);
requestPacket.addParseidPart(this.parseinfo.getParseId());
}
try {
replyPacket = this.connection.execute (requestPacket, this,
(!this.parseinfo.hasStreams && this.inputProcedureLongs==null)?ConnectionSapDB.GC_ALLOWED:ConnectionSapDB.GC_NONE);
// Recycling of parse infos and cursor names is not allowed
// if streams are in the command. Even sending it just behind
// as next packet is harmful. Same with INPUT LONG parameters of
// DB Procedures.
}
catch (SQLException dbExc) {
if ((dbExc.getErrorCode() == -8) && afterParseAgain > 0) {
this.resetPutvals (this.inputLongs);
this.reparse ();
this.connection.freeRequestPacket(requestPacket);
afterParseAgain--;
return this.execute (afterParseAgain);
}
else {
// The request packet has already been recycled in
// Connection.execute()
throw dbExc;
}
}
// --- now it becomes difficult ...
if (this.parseinfo.isSelect) {
isQuery = this.parseResult(replyPacket, null, this.parseinfo
.getColumnInfos(), this.parseinfo.columnNames);
} else {
if(inputProcedureLongs != null) {
replyPacket = this.processProcedureStreams(replyPacket);
} else if (this.parseinfo.hasStreams) {
replyPacket = this.processOMSStreams(replyPacket);
}
isQuery = this.parseResult(replyPacket, null, this.parseinfo
.getColumnInfos(), this.parseinfo.columnNames);
int returnCode = replyPacket.returnCode();
if (replyPacket.existsPart(PartKind.Data_C)) {
this.replyMem = replyPacket.getPointer(replyPacket
.getPartDataPos());
}
if ((this.parseinfo.hasLongs && !this.parseinfo.isDBProc) && (returnCode == 0)) {
this.handleStreamsForPutval(replyPacket);
}
}
return isQuery;
}
catch (TimeoutException timeout) {
if (this.connection.isInTransaction()
|| this.statementType == Statement_UpdatableResultSet ) {
throw timeout;
} else {
this.closeResultSet(true);
this.resetPutvals (this.inputLongs);
this.reparse ();
return this.execute (maxParseAgainCnt);
}
} finally{
this.canceled = false;
}
}
/**
* This method is inherited from java.sql.Statement. This method
* executes the current statement, which is in contrast to the standard. According to
* the standard, it has
* always to throw an java.sql.SQLException (JDBC, sec. 13.2.4).
* @param statement The statement (ignored).
* @exception java.sql.SQLException if a database error occurs during execution
* of the parsed statement.
*/
public boolean execute (
String sql)
throws SQLException
{
/*
* special hack for requisit
*/
return this.execute ();
/* boolean result; */
/* Statement stmt = this.connection.createStatement (); */
/* */
/* result = stmt.execute (sql); */
/* if (result) { */
/* this.currentResultSet = (ResultSetSapDB) stmt.getResultSet (); */
/* this.rowsAffected = stmt.getUpdateCount (); */
/* } */
/* return result; */
}
/**
*
*/
/**
* JDBC 2.0
*
* Submits a batch of commands to the database for execution.
* This method is optional.
*
* @return an array of update counts containing one element for each
* command in the batch. The array is ordered according
* to the order in which commands were inserted into the batch.
* @throws SQLException if a database access error occurs or the
* driver does not support batch statements
*/
public int[] executeBatch ()
throws SQLException
{
this.assertOpen ();
if (this.parseinfo != null
&& this.parseinfo.isSelect)
throw new BatchUpdateExceptionSapDB
(MessageTranslator.translate(MessageKey.ERROR_BATCHRESULTSET),
new int[0]);
if (this.parseinfo != null
&& (this.parseinfo.functionCode == FunctionCode.DBProcExecute_FC
|| this.parseinfo.functionCode == FunctionCode.DBProcWithResultSetExecute_FC)){
for (int i = 0; i < this.parseinfo.paramInfos.length; i++) {
if (this.parseinfo.paramInfos[i].isOutput())
throw new BatchUpdateExceptionSapDB
(MessageTranslator.translate(MessageKey.ERROR_BATCHPROCOUT),
new int[0]);
}
}
if (this.batchItems == null) {
return new int [0];
}
Vector streamVec = null;
boolean inTrans = this.connection.isInTransaction ();
java.util.Vector localBatchItems = this.batchItems;
this.batchItems = null;
try {
this.canceled = false;
int count = localBatchItems.size ();
RequestPacket requestPacket;
ReplyPacket replyPacket = null;
int inputCursor = 0;
boolean noError = true;
int recordSize = 0;
int insertCountPartSize = RequestPacket.resultCountPartSize ();
int executeCount = -1;
int [] result = new int[count];
this.rowsAffected = -1;
/*initialize update counts*/
for (int i = 0; i < result.length; i++) {
result[i]=StatementSapDB.BATCH_SUCCESS_NO_INFO_C;
}
if (this.parseinfo.getMassParseid() == null) {
this.parseMassCmd(false);
}
if (this.parseinfo.paramInfos.length > 0) {
recordSize = this.calculateInputRecord ();
}
while ((inputCursor < count) && noError) {
streamVec = null;
int firstRecordNo = inputCursor;
requestPacket = this.connection.getRequestPacket(this.packetEncodingUnicode);
requestPacket.initExecute (this.parseinfo.getMassParseid(),
this.connection.autocommit,
this.resultSetType);
if (executeCount == -1) {
requestPacket.addUndefResultCount ();
}
else {
requestPacket.addResultCount(executeCount);
}
requestPacket.addCursorPart (this.cursorName);
DataPart dataPart;
if (this.parseinfo.paramInfos.length > 0) {
dataPart = requestPacket.newDataPart (this.parseinfo.varDataInput);
if (executeCount == -1) {
dataPart.setFirstPart ();
}
do {
Object [] row = (Object []) localBatchItems.elementAt(inputCursor);
dataPart.addRow(this.parseinfo.inputCount);
for (int i = 0; i < this.parseinfo.paramInfos.length; ++i) {
/*check whether the parameter was set by application or throw an exception*/
if (this.parseinfo.paramInfos[i].isInput()
&& initialParamValue == row [i])
throw new BatchUpdateExceptionSapDB (MessageTranslator.translate(MessageKey.ERROR_BATCHMISSINGIN,
Integer.toString(inputCursor+1),
Integer.toString(i+1)),
"0200", makeBatchCountArray(result));
this.parseinfo.paramInfos [i].put (dataPart, row [i]);
}
if (this.parseinfo.hasLongs) {
this.handleStreamsForExecute (dataPart, row);
if (streamVec == null)
streamVec = new Vector(this.inputLongs.size());
streamVec.addAll(this.inputLongs);
}
dataPart.moveRecordBase ();
++inputCursor;
} while ((inputCursor < count)
&& dataPart.hasRoomFor (recordSize, insertCountPartSize)
&& this.parseinfo.isMassCmd());
if (inputCursor == count) {
dataPart.setLastPart ();
}
dataPart.closeArrayPart (inputCursor - firstRecordNo);
}
else{
++inputCursor; //commands without parameters
}
try {
replyPacket = this.connection.execute (requestPacket, this, ConnectionSapDB.GC_DELAYED);
}
catch (SQLException dbExc) {
if (dbExc.getErrorCode() == -8) {
this.resetPutvals (streamVec);
this.parseMassCmd(true);
inputCursor = firstRecordNo;
continue; // redo this packet
}
else {
SQLExceptionSapDB specific = (SQLExceptionSapDB) dbExc;
// An autocommit session does roll back automatically all what was
// in this package. Thus, in case of an error we must not
// add the current count from the packet.
if(!this.connection.getAutoCommit()) {
if(this.rowsAffected >0) {
this.rowsAffected += specific.getErrorPos () - 1;
} else {
this.rowsAffected = specific.getErrorPos () - 1;
}
}
throw new BatchUpdateExceptionSapDB (dbExc,
new Integer(inputCursor + 1),
makeBatchCountArray(result));
}
}
executeCount = replyPacket.resultCount (false);
if (this.parseinfo.hasLongs) {
this.handleStreamsForPutval (replyPacket);
}
if (! this.parseinfo.isMassCmd()
&& executeCount != -1){
result[inputCursor-1] = executeCount;
if(this.rowsAffected >0) {
this.rowsAffected += executeCount;
} else {
this.rowsAffected = executeCount;
}
}else {
this.rowsAffected = executeCount;
}
}
return result;
}
catch (TimeoutException timeout) {
if (inTrans
|| this.statementType == Statement_UpdatableResultSet) {
throw timeout;
}
else {
this.batchItems = localBatchItems;
this.resetPutvals (streamVec);
return this.executeBatch ();
}
} finally{
this.canceled = false;
}
}
private int[] makeBatchCountArray(int [] resultArr)
{
int [] erg;
if (this.rowsAffected > 0) {
erg = new int [this.rowsAffected];
System.arraycopy(resultArr,0,erg,0,erg.length);
}
else {
erg = new int [0];
}
return erg;
}
/**
* executeQuery method comment.
*/
public java.sql.ResultSet executeQuery()
throws java.sql.SQLException
{
if (this.parseinfo != null
&& ! this.parseinfo.isSelect) {
throw new SQLExceptionSapDB(MessageTranslator.translate(MessageKey.ERROR_SQLSTATEMENT_ROWCOUNT));
} else {
this.execute ();
return this.currentResultSet;
}
}
/**
* This method is inherited from java.sql.Statement. It has
* always to throw an java.sql.SQLException (JDBC, sec. 13.2.4).
* @param statement The statement (ignored).
* @exception java.sql.SQLException always
*/
public java.sql.ResultSet executeQuery(String statement)
throws java.sql.SQLException
{
throw new SQLExceptionSapDB(MessageTranslator.translate
(MessageKey.ERROR_EXECUTEQUERY_PREPAREDSTATEMENT));
}
/**
* executeQuery method comment.
*/
public ResultSetSapDB executeQuerySap ()
throws java.sql.SQLException
{
if (this.parseinfo != null
&& ! this.parseinfo.isSelect) {
throw new SQLExceptionSapDB(MessageTranslator.translate(MessageKey.ERROR_SQLSTATEMENT_ROWCOUNT));
}
return(ResultSetSapDB) this.currentResultSet;
}
/**
*
*/
public int executeUpdate()
throws java.sql.SQLException
{
if (this.parseinfo != null
&& this.parseinfo.isSelect) {
throw new SQLExceptionSapDB(MessageTranslator.translate(MessageKey.ERROR_SQLSTATEMENT_RESULTSET));
} else {
this.execute ();
if(this.hasRowCount) {
return this.rowsAffected;
} else {
return 0;
}
}
}
/**
* This method is inherited from java.sql.Statement. It has
* always to throw an java.sql.SQLException (JDBC, sec. 13.2.4).
* @param statement The statement (ignored).
* @exception java.sql.SQLException always
*/
public int executeUpdate(String statement)
throws java.sql.SQLException
{
throw new SQLExceptionSapDB(MessageTranslator.translate
(MessageKey.ERROR_EXECUTEUPDATE_PREPAREDSTATEMENT));
}
/**
* findColumn method comment.
*/
private DBTechTranslator findColInfo (
int colIndex)
throws SQLException
{
DBTechTranslator info;
try {
info = this.parseinfo.paramInfos [colIndex - 1];
}
catch (ArrayIndexOutOfBoundsException exc) {
throw new JDBCDriverException
(MessageTranslator.translate(MessageKey.ERROR_COLINDEX_NOTFOUND,
Integer.toString(colIndex)),
this);
}
return info;
}
private DBTechTranslator findParamInfo (String paramName)
throws SQLException
{
if (!this.parseinfo.isDBProc) {
throw new SQLExceptionSapDB
(MessageTranslator.translate(MessageKey.ERROR_SQLSTATEMENT_NOPROCEDURE));
}
if (this.columnMap == null) {
this.columnMap = this.parseinfo.getColumnMap ();
}
DBTechTranslator info = (DBTechTranslator) this.columnMap.get (paramName);
if (info == null) {
info = (DBTechTranslator)
this.columnMap.get (paramName.toUpperCase ());
if (info != null) {
// cache different case for faster lookup next time
this.columnMap.put (paramName, info);
}
}
if (info == null) {
/*maybe the parameter couldn't retrieved because of kernel bug*/
throw new InvalidColumnException (paramName, this);
}
return info;
}
/**
* JDBC 2.0
*
* Gets the value of a JDBC ARRAY parameter as an
* {@link Array} object in the Java programming language.
* @param i the first parameter is 1, the second is 2, and
* so on
* @return the parameter value as an Array object in
* the Java programming language. If the value was SQL NULL, the
* value null is returned.
* @exception SQLException if a database access error occurs
*/
public Array getArray (int i)
throws SQLException
{
throwNotSupported(MessageTranslator.translate(MessageKey.ERROR_ARRAY_UNSUPPORTED));
return null;
}
//--------------------------JDBC 2.0-----------------------------
/**
* JDBC 2.0
*
* Gets the value of a JDBC NUMERIC parameter as a
* java.math.BigDecimal object with as many digits to the
* right of the decimal point as the value contains.
* @param parameterIndex the first parameter is 1, the second is 2,
* and so on
* @return the parameter value in full precision. If the value is
* SQL NULL, the result is null.
* @exception SQLException if a database access error occurs
*/
public java.math.BigDecimal getBigDecimal(
int parameterIndex)
throws SQLException
{
assertOpen();
return this.findColInfo (parameterIndex).getBigDecimal (this, this.getReplyData());
}
/**
* getBigDecimal method comment.
*/
public java.math.BigDecimal getBigDecimal(
int parameterIndex,
int scale)
throws java.sql.SQLException
{
assertOpen();
return this.findColInfo (parameterIndex).getBigDecimal (scale, this, this.getReplyData());
}
/**
* JDBC 2.0
*
* Gets the value of a JDBC BLOB parameter as a
* {@link Blob} object in the Java programming language.
* @param i the first parameter is 1, the second is 2, and so on
* @return the parameter value as a Blob object in the
* Java programming language. If the value was SQL NULL, the value
* null is returned.
* @exception SQLException if a database access error occurs
*/
public Blob getBlob (
int i)
throws SQLException
{
assertOpen();
return this.findColInfo (i).getBlob (this, this.getReplyData(), this.getReplyData());
}
/**
* getBoolean method comment.
*/
public boolean getBoolean(
int parameterIndex)
throws java.sql.SQLException
{
assertOpen();
return this.findColInfo (parameterIndex).getBoolean (this, this.getReplyData());
}
/**
* getByte method comment.
*/
public byte getByte(
int parameterIndex)
throws java.sql.SQLException
{
assertOpen();
return this.findColInfo (parameterIndex).getByte (this, this.getReplyData());
}
/**
* getBytes method comment.
*/
public byte[] getBytes(int parameterIndex)
throws java.sql.SQLException {
assertOpen();
return this.findColInfo (parameterIndex).getBytes (this, this.getReplyData());
}
/**
* JDBC 2.0
*
* Gets the value of a JDBC CLOB parameter as a
* Clob object in the Java programming language.
* @param i the first parameter is 1, the second is 2, and
* so on
* @return the parameter value as a Clob object in the
* Java programming language. If the value was SQL NULL, the
* value null is returned.
* @exception SQLException if a database access error occurs
*/
public Clob getClob (
int i)
throws SQLException
{
assertOpen();
return this.findColInfo (i).getClob (this, this.getReplyData(), this.getReplyData());
}
/**
* getDate method comment.
*/
public java.sql.Date getDate(
int parameterIndex)
throws java.sql.SQLException
{
assertOpen();
return this.findColInfo (parameterIndex).getDate (this, this.getReplyData(),null);
}
/**
* Gets the value of a JDBC DATE parameter as a
* java.sql.Date object, using
* the given Calendar object
* to construct the date.
* With a Calendar object, the driver
* can calculate the date taking into account a custom timezone and locale.
* If no Calendar object is specified, the driver uses the
* default timezone and locale.
*
* @param parameterIndex the first parameter is 1, the second is 2,
* and so on
* @param cal the Calendar object the driver will use
* to construct the date
* @return the parameter value. If the value is SQL NULL, the result is
* null.
* @exception SQLException if a database access error occurs
*/
public java.sql.Date getDate(int parameterIndex,
Calendar cal)
throws SQLException
{
assertOpen();
return this.findColInfo (parameterIndex).getDate (this, this.getReplyData(),cal);
}
/**
* getDouble method comment.
*/
public double getDouble(
int parameterIndex)
throws java.sql.SQLException
{
assertOpen();
return this.findColInfo (parameterIndex).getDouble (this, this.getReplyData());
}
/**
* getFloat method comment.
*/
public float getFloat(
int parameterIndex)
throws java.sql.SQLException
{
assertOpen();
return this.findColInfo (parameterIndex).getFloat (this, this.getReplyData());
}
/**
*
* @return java.lang.Object
* @param index int
*/
Object getInputParameter (
int parameterIndex)
{
return this.inputArgs [parameterIndex - 1];
}
/**
* getInt method comment.
*/
public int getInt(
int parameterIndex)
throws java.sql.SQLException
{
assertOpen();
return this.findColInfo (parameterIndex).getInt (this, this.getReplyData());
}
/**
* getLong method comment.
*/
public long getLong(
int parameterIndex)
throws java.sql.SQLException
{
assertOpen();
return this.findColInfo (parameterIndex).getLong (this, this.getReplyData());
}
/**
* JDBC 2.0
*
* Gets the number, types and properties of a ResultSet's columns.
*
*
* @return the description of a ResultSet's columns
* @exception SQLException if a database access error occurs
*/
public ResultSetMetaData getMetaData()
throws SQLException
{
if(this.fetchInfo==null) {
if(this.parseinfo==null) {
return null;
} else {
if( (! this.parseinfo.isSelect)
&& (this.parseinfo.functionCode != FunctionCode.Select_FC)
&& (this.parseinfo.functionCode != FunctionCode.DBProcWithResultSetExecute_FC)) {
// leave as is if this is not a simple select
return null;
}
DBTechTranslator[] colinfos=this.parseinfo.getColumnInfos();
if(colinfos!=null) {
return new ResultSetMetaDataSapDB(colinfos);
} else {
// send describe parseid
try {
this.parseinfo.doDescribeParseId();
}
catch (Exception ex) {
return null;
}
return new ResultSetMetaDataSapDB (
this.getFetchInfo(this.cursorName,
this.parseinfo.getColumnInfos(),
this.parseinfo.columnNames).getColInfo());
}
}
} else {
return new ResultSetMetaDataSapDB (this.fetchInfo.getColInfo());
}
}
/**
* getObject method comment.
*/
public Object getObject(
int parameterIndex)
throws java.sql.SQLException
{
assertOpen();
Object result=null;
int typeCode;
int scale;
DBTechTranslator translator = this.findColInfo (parameterIndex);
StructuredMem replymem = this.getReplyData();
if (this.outPutTypes == null) {
typeCode = 0;
}
else {
typeCode = this.outPutTypes [parameterIndex];
}
switch (typeCode) {
case Types.BIT:
if(!translator.isNull(this, replymem))
result = new Boolean (translator.getBoolean(this, replymem));
break;
case Types.TINYINT:
if(!translator.isNull(this, replymem))
result = new Byte (translator.getByte (this, replymem));
break;
case Types.SMALLINT:
if(!translator.isNull(this, replymem))
result = new Short (translator.getShort (this, replymem));
break;
case Types.INTEGER:
if(!translator.isNull(this, replymem))
result = new Integer (translator.getInt (this, replymem));
break;
case Types.BIGINT:
if(!translator.isNull(this, replymem))
result = new Long (translator.getLong (this, replymem));
break;
case Types.REAL:
if(!translator.isNull(this, replymem))
result = new Float (translator.getFloat (this, replymem));
break;
case Types.FLOAT:
if(!translator.isNull(this, replymem))
result = new Float (translator.getFloat (this, replymem));
break;
case Types.DOUBLE:
if(!translator.isNull(this, replymem))
result = new Double (translator.getDouble (this, replymem));
break;
case Types.NUMERIC:
case Types.DECIMAL:
scale = this.outPutScale [parameterIndex];
if (scale == -1) {
result = translator.getBigDecimal(this, replymem);
}
else {
result = translator.getBigDecimal(scale, this, replymem);
}
break;
case Types.CHAR:
case Types.VARCHAR:
case Types.LONGVARCHAR:
result = translator.getString (this, replymem);
break;
case Types.DATE:
result = translator.getDate (this, replymem, null);
break;
case Types.TIME:
result = translator.getTime (this, replymem, null);
break;
case Types.TIMESTAMP:
result = translator.getTimestamp(this, replymem, null);
break;
case Types.BINARY:
case Types.VARBINARY:
case Types.LONGVARBINARY:
result = translator.getBytes (this, replymem);
break;
case java.sql.Types.BLOB:
result = translator.getBlob (this, replymem, replymem);
break;
case java.sql.Types.CLOB:
result = translator.getClob (this, replymem, replymem);
break;
default:
result = translator.getObject (this, replymem);
}
return result;
}
/**
* JDBC 2.0
*
* Returns an object representing the value of OUT parameter
* i and uses map for the custom
* mapping of the parameter value.
*
* This method returns a Java object whose type corresponds to the
* JDBC type that was registered for this parameter using the method
* Note: When reading the value of an out parameter, you
* must use the Note: This stream object can either be a standard
* Java stream object or your own subclass that implements the
* standard interface.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the java reader which contains the UNICODE data
* @param length the number of characters in the stream
* @exception SQLException if a database access error occurs
*/
public void setCharacterStream(
int parameterIndex,
java.io.Reader reader,
int length)
throws SQLException
{
Object arg = this.findColInfo (parameterIndex).transCharacterStreamForInput (reader, length);
this.inputArgs [parameterIndex - 1] = arg;
}
/**
* JDBC 2.0
*
* Sets a CLOB parameter.
*
* @param i the first parameter is 1, the second is 2, ...
* @param x an object representing a CLOB
* @exception SQLException if a database access error occurs
*/
public void setClob (
int i,
Clob x)
throws SQLException
{
Object arg = this.findColInfo (i).transClobForInput (x);
this.inputArgs [i - 1] = arg;
}
/**
* setDate method comment.
*/
public void setDate(
int parameterIndex,
java.sql.Date x)
throws java.sql.SQLException
{
this.setDate(parameterIndex,x,null);
}
/**
* JDBC 2.0
*
* Sets the designated parameter to a java.sql.Date value,
* using the given Note: To be portable, applications must give the
* SQL type code and the fully-qualified SQL type name when specifying
* a NULL user-defined or REF parameter. In the case of a user-named type
* the name is the type name of the parameter itself. For a REF
* parameter the name is the type name of the referenced type. If
* a JDBC driver does not need the type code or type name information,
* it may ignore it.
*
* Although it is intended for user-named and Ref parameters,
* this method may be used to set a null parameter of any JDBC type.
* If the parameter does not have a user-named or REF type, the given
* typeName is ignored.
*
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param sqlType a value from java.sql.Types
* @param typeName the fully-qualified name of an SQL user-named type,
* ignored if the parameter is not a user-named type or REF
* @exception SQLException if a database access error occurs
*/
public void setNull (
int paramIndex,
int sqlType,
String typeName)
throws java.sql.SQLException
{
this.setNull (paramIndex, sqlType);
}
/**
* setObject method comment.
*/
public void setObject(
int parameterIndex,
Object x)
throws java.sql.SQLException
{
Object arg = this.findColInfo (parameterIndex).transObjectForInput (x);
this.inputArgs [parameterIndex - 1] = arg;
}
/**
* setObject method comment.
*/
public void setObject(
int parameterIndex,
Object x,
int targetSqlType)
throws java.sql.SQLException
{
// specials for JDBC Compliance
switch(targetSqlType) {
case Types.INTEGER:
if(x instanceof Number) {
Number n=(Number)x;
this.setInt(parameterIndex, n.intValue());
return;
}
case Types.BIGINT:
if(x instanceof Number) {
Number n=(Number)x;
this.setLong(parameterIndex, n.longValue());
return;
}
}
this.setObject (parameterIndex, x);
}
/**
* setObject method comment.
*/
public void setObject(
int parameterIndex,
Object x,
int targetSqlType,
int scale)
throws java.sql.SQLException
{
// ignore targetSqlType
this.setObject (parameterIndex, x, scale);
}
/**
* JDBC 2.0
*
* Sets a REF(<structured-type>) parameter.
*
* @param i the first parameter is 1, the second is 2, ...
* @param x an object representing data of an SQL REF Type
* @exception SQLException if a database access error occurs
*/
public void setRef (int i,
Ref x)
throws SQLException
{
throwNotSupported(MessageTranslator.translate(MessageKey.ERROR_REF_UNSUPPORTED));
}
/**
* setShort method comment.
*/
public void setShort(
int parameterIndex,
short x)
throws java.sql.SQLException
{
Object arg = this.findColInfo (parameterIndex).transShortForInput (x);
this.inputArgs [parameterIndex - 1] = arg;
}
/**
* setString method comment.
*/
public void setString(
int parameterIndex,
String x)
throws java.sql.SQLException
{
this.assertOpen();
if ( x != null
&& this.connection.isSQLModeOracle
&& x.equalsIgnoreCase("") ) {
/* in oracle mode a null values will be inserted
if the string value is equal to "" */
this.inputArgs [parameterIndex - 1] = null;
}
else {
Object arg = this.findColInfo (parameterIndex).transStringForInput (x);
this.inputArgs [parameterIndex - 1] = arg;
}
}
/**
* setTime method comment.
*/
public void setTime(
int parameterIndex,
java.sql.Time x)
throws java.sql.SQLException
{
this.setTime(parameterIndex,x, null);
}
/**
* JDBC 2.0
*
* Sets the designated parameter to a java.sql.Time value,
* using the given registerOutParameter. By registering the target
* JDBC type as java.sql.Types.OTHER, this method can
* be used to read database-specific abstract data types.
* @param i the first parameter is 1, the second is 2, and so on
* @param map the mapping from SQL type names to Java classes
* @return a java.lang.Object holding the OUT parameter value.
* @exception SQLException if a database access error occurs
*/
public Object getObject (int i,
Map map)
throws SQLException
{
throw new NotImplemented (MessageTranslator.translate(MessageKey.ERROR_GETOBJECT_NOTIMPLEMENTED));
}
/**
* JDBC 2.0
*
* Gets the value of a JDBC REF(<structured-type>)
* parameter as a {@link Ref} object in the Java programming language.
* @param i the first parameter is 1, the second is 2,
* and so on
* @return the parameter value as a Ref object in the
* Java programming language. If the value was SQL NULL, the value
* null is returned.
* @exception SQLException if a database access error occurs
*/
public Ref getRef (int i)
throws SQLException
{
throwNotSupported(MessageTranslator.translate(MessageKey.ERROR_REF_UNSUPPORTED));
return null;
}
/**
*
* @return com.sap.dbtech.util.StructuredMem
*/
public StructuredMem getReplyData ()
throws SQLException
{
if(this.replyMem==null &&
((this.outputOMSStreams==null)
||(this.outputOMSStreams!=null && this.outputOMSStreams.size()==0))) {
throw new SQLExceptionSapDB(MessageTranslator.translate
(MessageKey.ERROR_NOOUTPARAMDATA));
}
return this.replyMem;
}
/**
* getShort method comment.
*/
public short getShort(
int parameterIndex)
throws java.sql.SQLException
{
return this.findColInfo (parameterIndex).getShort (this, this.getReplyData());
}
/**
* getString method comment.
*/
public String getString(
int parameterIndex)
throws java.sql.SQLException
{
return this.findColInfo (parameterIndex).getString (this, this.getReplyData());
}
/**
* getTime method comment.
*/
public java.sql.Time getTime(
int parameterIndex)
throws java.sql.SQLException
{
return this.findColInfo (parameterIndex).getTime (this, this.getReplyData(),null);
}
/**
* Gets the value of a JDBC TIME parameter as a
* java.sql.Time object, using
* the given Calendar object
* to construct the time.
* With a Calendar object, the driver
* can calculate the time taking into account a custom timezone and locale.
* If no Calendar object is specified, the driver uses the
* default timezone and locale.
*
* @param parameterIndex the first parameter is 1, the second is 2,
* and so on
* @param cal the Calendar object the driver will use
* to construct the time
* @return the parameter value; if the value is SQL NULL, the result is
* null.
* @exception SQLException if a database access error occurs
*/
public java.sql.Time getTime(
int parameterIndex,
Calendar cal)
throws SQLException
{
return this.findColInfo (parameterIndex).getTime (this, this.getReplyData(),cal);
}
/**
* getTimestamp method comment.
*/
public java.sql.Timestamp getTimestamp(int parameterIndex) throws java.sql.SQLException {
return this.findColInfo (parameterIndex).getTimestamp (this, this.getReplyData(),null);
}
/**
* Gets the value of a JDBC TIMESTAMP parameter as a
* java.sql.Timestamp object, using
* the given Calendar object to construct
* the Timestamp object.
* With a Calendar object, the driver
* can calculate the timestamp taking into account a custom timezone and locale.
* If no Calendar object is specified, the driver uses the
* default timezone and locale.
*
*
* @param parameterIndex the first parameter is 1, the second is 2,
* and so on
* @param cal the Calendar object the driver will use
* to construct the timestamp
* @return the parameter value. If the value is SQL NULL, the result is
* null.
* @exception SQLException if a database access error occurs
*/
public java.sql.Timestamp getTimestamp(int parameterIndex,
Calendar cal)
throws SQLException
{
return this.findColInfo (parameterIndex).getTimestamp (this, this.getReplyData(),cal);
}
private static class PutvalComparator implements Comparator
{
public int compare(Object o1, Object o2)
{
Putval p1 = (Putval) o1;
Putval p2 = (Putval) o2;
int p1_bufpos = p1.getBufpos();
int p2_bufpos = p2.getBufpos();
return p1_bufpos - p2_bufpos;
}
public boolean equals(Object o)
{
return o==this;
}
}
private static final PutvalComparator putvalComparator = new PutvalComparator();
/**
*
* @exception java.sql.SQLException The exception description.
*/
private void handleStreamsForExecute (DataPart dataPart,
Object [] arguments)
throws SQLException
{
Putval putval;
Enumeration putvals;
int i;
/*
* get all putval objects
*/
this.inputLongs = new Vector ();
for (i = 0; i < this.parseinfo.paramInfos.length; ++i) {
Object inarg = arguments [i];
if (inarg == null) {
continue;
}
try {
putval = (Putval) inarg;
this.inputLongs.addElement (putval);
}
catch (ClassCastException exc) {
// not a long for input, ignore
}
}
if(this.inputLongs.size()>1) {
Collections.sort(this.inputLongs, putvalComparator);
}
/*
* write data (and patch descriptor)
*/
putvals = this.inputLongs.elements ();
for (i = 0; putvals.hasMoreElements (); ++i) {
putval = (Putval) putvals.nextElement ();
if (putval.atEnd()){
throw new SQLExceptionSapDB(MessageTranslator.translate(MessageKey.ERROR_STREAM_ISATEND));
}
putval.transferStream (dataPart, i);
}
}
private void handleProcedureStreamsForExecute(DataPart dataPart, Object[] objects)throws SQLExceptionSapDB
{
this.inputProcedureLongs = new Vector();
for(int i=0; iregisterOutParameter
* should be used for a user-named or REF output parameter. Examples
* of user-named types include: STRUCT, DISTINCT, JAVA_OBJECT, and
* named array types.
*
* Before executing a stored procedure call, you must explicitly
* call registerOutParameter to register the type from
* java.sql.Types for each
* OUT parameter. For a user-named parameter the fully-qualified SQL
* type name of the parameter should also be given, while a REF
* parameter requires that the fully-qualified type name of the
* referenced type be given. A JDBC driver that does not need the
* type code and type name information may ignore it. To be portable,
* however, applications should always provide these values for
* user-named and REF parameters.
*
* Although it is intended for user-named and REF parameters,
* this method may be used to register a parameter of any JDBC type.
* If the parameter does not have a user-named or REF type, the
* typeName parameter is ignored.
*
* getYYY method whose Java type YYY corresponds to the
* parameter's registered SQL type.
*
* @param parameterIndex the first parameter is 1, the second is 2,...
* @param sqlType a value from java.sql.Types
* @param typeName the fully-qualified name of an SQL structured type
* @exception SQLException if a database-access error occurs
*/
public void registerOutParameter (
int paramIndex,
int sqlType,
String typeName)
throws SQLException
{
this.registerOutParameter (paramIndex, sqlType, -1);
}
/**
* Overwrites the inherited method. Instead of executing the command,
* this does a parse only!
* @param requestPacket the request packet.
* @param sqlCmd the SQL command to parse.
* @exception java.sql.SQLException if a database error occurs.
*/
ReplyPacket sendCommand (
RequestPacket requestPacket,
String sqlCmd,
int gcFlags,
boolean parseAgain)
throws SQLException
{
ReplyPacket replyPacket;
requestPacket.initParseCommand (sqlCmd, true, parseAgain);
if(setWithInfo)
requestPacket.setWithInfo();
replyPacket = this.connection.execute (requestPacket, false, true, this,
gcFlags);
return replyPacket;
}
/**
* JDBC 2.0
*
* Sets an Array parameter.
*
* @param i the first parameter is 1, the second is 2, ...
* @param x an object representing an SQL array
* @exception SQLException if a database access error occurs
*/
public void setArray (int i,
Array x)
throws SQLException
{
throwNotSupported(MessageTranslator.translate(MessageKey.ERROR_ARRAY_UNSUPPORTED));
}
/**
* setAsciiStream method comment.
*/
public void setAsciiStream(
int parameterIndex,
java.io.InputStream x,
int length)
throws java.sql.SQLException
{
Object arg = this.findColInfo (parameterIndex).transAsciiStreamForInput (x,length);
this.inputArgs [parameterIndex - 1] = arg;
}
/**
* setBigDecimal method comment.
*/
public void setBigDecimal(
int parameterIndex,
java.math.BigDecimal x)
throws java.sql.SQLException
{
Object arg = this.findColInfo (parameterIndex).transBigDecimalForInput (x);
this.inputArgs [parameterIndex - 1] = arg;
}
/**
* setBinaryStream method comment.
*/
public void setBinaryStream(
int parameterIndex,
java.io.InputStream x,
int length)
throws java.sql.SQLException
{
Object arg = this.findColInfo (parameterIndex).transBinaryStreamForInput (x,length);
this.inputArgs [parameterIndex - 1] = arg;
}
/**
* JDBC 2.0
*
* Sets a BLOB parameter.
*
* @param i the first parameter is 1, the second is 2, ...
* @param x an object representing a BLOB
* @exception SQLException if a database access error occurs
*/
public void setBlob (
int i,
Blob x)
throws SQLException
{
Object arg = this.findColInfo (i).transBlobForInput (x);
this.inputArgs [i - 1] = arg;
}
/**
* setBoolean method comment.
*/
public void setBoolean(
int parameterIndex,
boolean x)
throws java.sql.SQLException
{
Object arg = this.findColInfo (parameterIndex).transBooleanForInput (x);
this.inputArgs [parameterIndex - 1] = arg;
}
/**
* setByte method comment.
*/
public void setByte(
int parameterIndex,
byte x)
throws java.sql.SQLException
{
Object arg = this.findColInfo (parameterIndex).transByteForInput (x);
this.inputArgs [parameterIndex - 1] = arg;
}
/**
* setBytes method comment.
*/
public void setBytes(
int parameterIndex,
byte[] x)
throws java.sql.SQLException
{
Object arg = this.findColInfo (parameterIndex).transBytesForInput (x);
this.inputArgs [parameterIndex - 1] = arg;
}
/**
* JDBC 2.0
*
* Sets the designated parameter to the given Reader
* object, which is the given number of characters long.
* When a very large UNICODE value is input to a LONGVARCHAR
* parameter, it may be more practical to send it via a
* java.io.Reader. JDBC will read the data from the stream
* as needed, until it reaches end-of-file. The JDBC driver will
* do any necessary conversion from UNICODE to the database char format.
*
* Calendar object. The driver uses
* the Calendar object to construct an SQL DATE,
* which the driver then sends to the database. With a
* a Calendar object, the driver can calculate the date
* taking into account a custom timezone and locale. If no
* Calendar object is specified, the driver uses the default
* timezone and locale.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the parameter value
* @param cal the Calendar object the driver will use
* to construct the date
* @exception SQLException if a database access error occurs
*/
public void setDate(
int parameterIndex,
java.sql.Date x,
Calendar cal)
throws SQLException
{
if(cal==null) {
cal=Calendar.getInstance();
}
Object arg = this.findColInfo (parameterIndex).transDateForInput (x,cal);
this.inputArgs [parameterIndex - 1] = arg;
}
/**
* setDouble method comment.
*/
public void setDouble(
int parameterIndex,
double x)
throws java.sql.SQLException
{
Object arg = this.findColInfo (parameterIndex).transDoubleForInput (x);
this.inputArgs [parameterIndex - 1] = arg;
}
/**
* setFloat method comment.
*/
public void setFloat(
int parameterIndex,
float x)
throws java.sql.SQLException
{
Object arg = this.findColInfo (parameterIndex).transFloatForInput (x);
this.inputArgs [parameterIndex - 1] = arg;
}
/**
* setInt method comment.
*/
public void setInt(int parameterIndex,
int x)
throws java.sql.SQLException
{
Object arg = this.findColInfo (parameterIndex).transIntForInput (x);
this.inputArgs [parameterIndex - 1] = arg;
}
/**
*
* @param wasNull boolean
*/
public void setLastWasNull (
boolean wasNull)
{
this.lastWasNull = wasNull;
}
/**
* setLong method comment.
*/
public void setLong(
int parameterIndex,
long x)
throws java.sql.SQLException
{
Object arg = this.findColInfo (parameterIndex).transLongForInput (x);
this.inputArgs [parameterIndex - 1] = arg;
}
/**
* setNull method comment.
*/
public void setNull(
int parameterIndex,
int sqlType)
throws java.sql.SQLException
{
this.inputArgs [parameterIndex - 1] = null;
}
public void setDefault(
int parameterIndex)
throws java.sql.SQLException
{
this.inputArgs [parameterIndex - 1] = DBTechTranslator.DefaultValue;
}
/**
* JDBC 2.0
*
* Sets the designated parameter to SQL NULL. This version of setNull should
* be used for user-named types and REF type parameters. Examples
* of user-named types include: STRUCT, DISTINCT, JAVA_OBJECT, and
* named array types.
*
* Calendar object. The driver uses
* the Calendar object to construct an SQL TIME,
* which the driver then sends to the database. With a
* a Calendar object, the driver can calculate the time
* taking into account a custom timezone and locale. If no
* Calendar object is specified, the driver uses the default
* timezone and locale.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the parameter value
* @param cal the Calendar object the driver will use
* to construct the time
* @exception SQLException if a database access error occurs
*/
public void setTime(int parameterIndex,
java.sql.Time x,
Calendar cal)
throws SQLException
{
if(cal==null) {
cal=Calendar.getInstance();
}
Object arg = this.findColInfo (parameterIndex).transTimeForInput (x, cal);
this.inputArgs [parameterIndex - 1] = arg;
}
/**
* setTimestamp method comment.
*/
public void setTimestamp(
int parameterIndex,
java.sql.Timestamp x)
throws java.sql.SQLException
{
this.setTimestamp(parameterIndex,x,null);
}
/**
* JDBC 2.0
*
* Sets the designated parameter to a java.sql.Timestamp value,
* using the given Calendar object. The driver uses
* the Calendar object to construct an SQL TIMESTAMP,
* which the driver then sends to the database. With a
* a Calendar object, the driver can calculate the timestamp
* taking into account a custom timezone and locale. If no
* Calendar object is specified, the driver uses the default
* timezone and locale.
*
* @param parameterIndex the first parameter is 1, the second is 2, ...
* @param x the parameter value
* @param cal the Calendar object the driver will use
* to construct the timestamp
* @exception SQLException if a database access error occurs
*/
public void setTimestamp(int parameterIndex,
java.sql.Timestamp x,
Calendar cal)
throws SQLException
{
if(cal==null) {
cal=Calendar.getInstance();
}
Object arg = this.findColInfo (parameterIndex).transTimestampForInput (x, cal);
this.inputArgs [parameterIndex - 1] = arg;
}
/**
* setUnicodeStream method comment.
*/
public void setUnicodeStream(
int parameterIndex,
java.io.InputStream x,
int length)
throws java.sql.SQLException
{
Object arg = this.findColInfo (parameterIndex).transUnicodeStreamForInput (x);
this.inputArgs [parameterIndex - 1] = arg;
}
/**
* wasNull method comment.
*/
public boolean wasNull()
throws java.sql.SQLException
{
return this.lastWasNull;
}
/**
*
*/
protected FetchInfo
getFetchInfo (
String cursorName,
DBTechTranslator [] infos,
String [] columnNames)
throws SQLException
{
if (this.fetchInfo == null) {
this.fetchInfo = new FetchInfo (this.connection,
cursorName, infos, columnNames, this.packetEncodingUnicode);
}
else {
if (!this.fetchInfo.getCursorName ().equals (cursorName)) {
this.fetchInfo = new FetchInfo (this.connection,
cursorName, infos, columnNames, this.packetEncodingUnicode);
}
}
return this.fetchInfo;
}
protected void updateFetchInfo(DBTechTranslator [] infos, String[] columnNames) throws SQLException {
this.parseinfo.setMetaData(infos, columnNames);
}
/**
*
*/
public void
close ()
throws SQLException
{
this.replyMem=null;
if (this.connection != null
&& this.parseinfo != null
&& !this.parseinfo.cached) {
this.connection.dropParseid (this.parseinfo.getParseId());
this.parseinfo.setParseIdAndSession(null, -1);
this.connection.dropParseid (this.parseinfo.getMassParseid());
this.parseinfo.setMassParseid(null);
}
super.close ();
}
/**
*
*/
protected void
resetPutvals (Vector inpLongs)
{
if (inpLongs != null) {
Enumeration putvals = inpLongs.elements ();
while (putvals.hasMoreElements ()) {
Putval putval = (Putval) putvals.nextElement ();
putval.reset ();
}
}
}
public void registerOutParameter(String parameterName, int sqlType) throws SQLException {
this.registerOutParameter (parameterName, sqlType, -1);
}
public void registerOutParameter(String parameterName, int sqlType, int scale) throws SQLException {
this.registerOutParameter((this.findParamInfo(parameterName).getColIndex())+1, sqlType, scale);
}
public void registerOutParameter(String parameterName, int sqlType, String typeName) throws SQLException {
this.registerOutParameter (parameterName, sqlType, -1);
}
public URL getURL(int parm1) throws java.sql.SQLException {
this.throwNotSupported("Type URL");
return null;
}
public void setURL(String parm1, URL parm2) throws java.sql.SQLException {
this.throwNotSupported("Type URL");
}
public void setNull(String parameterName, int sqlType) throws SQLException {
this.setNull((this.findParamInfo(parameterName).getColIndex())+1,sqlType);
}
public void setDefault(String parameterName) throws SQLException {
this.setDefault((this.findParamInfo(parameterName).getColIndex())+1);
}
public void setBoolean(String parameterName, boolean x) throws SQLException {
this.setBoolean((this.findParamInfo(parameterName).getColIndex())+1,x);
}
public void setByte(String parameterName, byte x) throws SQLException {
this.setByte((this.findParamInfo(parameterName).getColIndex())+1,x);
}
public void setShort(String parameterName, short x) throws SQLException {
this.setShort((this.findParamInfo(parameterName).getColIndex())+1,x);
}
public void setInt(String parameterName, int x) throws SQLException {
this.setInt((this.findParamInfo(parameterName).getColIndex())+1,x);
}
public void setLong(String parameterName, long x) throws SQLException {
this.setLong((this.findParamInfo(parameterName).getColIndex())+1,x);
}
public void setFloat(String parameterName, float x) throws SQLException {
this.setFloat((this.findParamInfo(parameterName).getColIndex())+1,x);
}
public void setDouble(String parameterName, double x) throws SQLException {
this.setDouble((this.findParamInfo(parameterName).getColIndex())+1,x);
}
public void setBigDecimal(String parameterName, BigDecimal x) throws SQLException {
this.setBigDecimal((this.findParamInfo(parameterName).getColIndex())+1,x);
}
public void setString(String parameterName, String x) throws SQLException {
this.setString((this.findParamInfo(parameterName).getColIndex())+1,x);
}
public void setBytes(String parameterName, byte[] x) throws SQLException {
this.setBytes((this.findParamInfo(parameterName).getColIndex())+1,x);
}
public void setDate(String parameterName, java.sql.Date x) throws SQLException {
this.setDate((this.findParamInfo(parameterName).getColIndex())+1,x);
}
public void setTime(String parameterName, java.sql.Time x) throws SQLException {
this.setTime((this.findParamInfo(parameterName).getColIndex())+1,x);
}
public void setTimestamp(String parameterName, java.sql.Timestamp x) throws SQLException {
this.setTimestamp((this.findParamInfo(parameterName).getColIndex())+1,x);
}
public void setAsciiStream(String parameterName, InputStream x, int length) throws SQLException {
this.setAsciiStream((this.findParamInfo(parameterName).getColIndex())+1,x,length);
}
public void setBinaryStream(String parameterName, InputStream x, int length) throws SQLException {
this.setBinaryStream((this.findParamInfo(parameterName).getColIndex())+1,x,length);
}
public void setObject(String parameterName, Object x, int targetSqlType, int scale) throws SQLException {
this.setObject((this.findParamInfo(parameterName).getColIndex())+1,x,targetSqlType,scale);
}
public void setObject(String parameterName, Object x, int targetSqlType) throws SQLException {
this.setObject((this.findParamInfo(parameterName).getColIndex())+1,x,targetSqlType);
}
public void setObject(String parameterName, Object x) throws SQLException {
this.setObject((this.findParamInfo(parameterName).getColIndex())+1,x);
}
public void setCharacterStream(String parameterName, Reader reader, int length) throws SQLException {
this.setCharacterStream((this.findParamInfo(parameterName).getColIndex())+1,reader,length);
}
public void setDate(String parameterName, java.sql.Date x, Calendar cal) throws SQLException {
this.setDate((this.findParamInfo(parameterName).getColIndex())+1,x,cal);
}
public void setTime(String parameterName, java.sql.Time x, Calendar cal) throws SQLException {
this.setTime((this.findParamInfo(parameterName).getColIndex())+1,x,cal);
}
public void setTimestamp(String parameterName, java.sql.Timestamp x, Calendar cal) throws SQLException {
this.setTimestamp((this.findParamInfo(parameterName).getColIndex())+1,x,cal);
}
public void setNull(String parameterName, int sqlType, String typeName) throws SQLException {
this.setNull((this.findParamInfo(parameterName).getColIndex())+1,sqlType,typeName);
}
public String getString(String parameterName) throws SQLException {
assertOpen();
return this.findParamInfo (parameterName).getString (this, this.getReplyData());
}
public boolean getBoolean(String parameterName) throws SQLException {
assertOpen();
return this.findParamInfo (parameterName).getBoolean (this, this.getReplyData());
}
public byte getByte(String parameterName) throws SQLException {
assertOpen();
return this.findParamInfo (parameterName).getByte (this, this.getReplyData());
}
public short getShort(String parameterName) throws SQLException {
assertOpen();
return this.findParamInfo (parameterName).getShort (this, this.getReplyData());
}
public int getInt(String parameterName) throws SQLException {
assertOpen();
return this.findParamInfo (parameterName).getInt (this, this.getReplyData());
}
public long getLong(String parameterName) throws SQLException {
assertOpen();
return this.findParamInfo (parameterName).getLong (this, this.getReplyData());
}
public float getFloat(String parameterName) throws SQLException {
assertOpen();
return this.findParamInfo (parameterName).getFloat (this, this.getReplyData());
}
public double getDouble(String parameterName) throws SQLException {
assertOpen();
return this.findParamInfo (parameterName).getDouble (this, this.getReplyData());
}
public byte[] getBytes(String parameterName) throws SQLException {
assertOpen();
return this.findParamInfo (parameterName).getBytes (this, this.getReplyData());
}
public java.sql.Date getDate(String parameterName) throws SQLException {
assertOpen();
return this.findParamInfo (parameterName).getDate (this, this.getReplyData(),null);
}
public java.sql.Time getTime(String parameterName) throws SQLException {
assertOpen();
return this.findParamInfo (parameterName).getTime (this, this.getReplyData(),null);
}
public java.sql.Timestamp getTimestamp(String parameterName) throws SQLException {
assertOpen();
return this.findParamInfo (parameterName).getTimestamp (this, this.getReplyData(),null);
}
public Object getObject(String parameterName) throws SQLException {
assertOpen();
return this.findParamInfo (parameterName).getObject (this, this.getReplyData());
}
public BigDecimal getBigDecimal(String parameterName) throws SQLException {
assertOpen();
return this.findParamInfo (parameterName).getBigDecimal (this, this.getReplyData());
}
public Object getObject(String parameterName, Map map) throws SQLException {
throw new NotImplemented ();
}
public Ref getRef(String parameterName) throws SQLException {
throwNotSupported(MessageTranslator.translate(MessageKey.ERROR_REF_UNSUPPORTED));
return null;
}
public Blob getBlob(String parameterName) throws SQLException {
assertOpen();
return this.findParamInfo (parameterName).getBlob (this, this.getReplyData(), this.getReplyData());
}
public Clob getClob(String parameterName) throws SQLException {
assertOpen();
return this.findParamInfo (parameterName).getClob (this, this.getReplyData(), this.getReplyData());
}
public Array getArray(String parameterName) throws SQLException {
throwNotSupported(MessageTranslator.translate(MessageKey.ERROR_ARRAY_UNSUPPORTED));
return null;
}
public java.sql.Date getDate(String parameterName, Calendar cal) throws SQLException {
assertOpen();
return this.findParamInfo (parameterName).getDate (this, this.getReplyData(),cal);
}
public java.sql.Time getTime(String parameterName, Calendar cal) throws SQLException {
assertOpen();
return this.findParamInfo (parameterName).getTime (this, this.getReplyData(),cal);
}
public java.sql.Timestamp getTimestamp(String parameterName, Calendar cal) throws SQLException {
assertOpen();
return this.findParamInfo (parameterName).getTimestamp (this, this.getReplyData(),cal);
}
public URL getURL(String parm1) throws java.sql.SQLException {
throwNotSupported(MessageTranslator.translate(MessageKey.ERROR_URL_UNSUPPORTED));
return null;
}
public void setURL(int parm1, URL parm2) throws java.sql.SQLException {
throwNotSupported(MessageTranslator.translate(MessageKey.ERROR_URL_UNSUPPORTED));
}
public java.sql.ParameterMetaData getParameterMetaData() throws java.sql.SQLException {
return ParameterMetaDataSapDB.createParameterMetaDataSapDB(this.parseinfo.getParamInfo());
}
public AbstractABAPStreamGetval getOMSGetval(int index)
throws SQLException {
if(this.outputOMSStreams == null) {
return null;
}
for(int i=0; i