// @@@ START COPYRIGHT @@@
//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
//
// @@@ END COPYRIGHT @@@

package org.trafodion.jdbc.t4;

import java.io.IOException;
import java.io.InputStream;
import java.math.BigDecimal;
import java.sql.DataTruncation;
import java.sql.Date;
import java.sql.SQLException;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Locale;
import java.util.logging.Level;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

class InterfaceStatement {
	InterfaceConnection ic_;
	private long rowCount_;
	static final short SQL_DROP = 1;
	static short EXTERNAL_STMT = 0;
	int sqlStmtType_ = TRANSPORT.TYPE_UNKNOWN;
	int stmtType_ = 0;
	T4Statement t4statement_;
	int queryTimeout_;
	String stmtLabel_;
	String cursorName_;
	TrafT4Statement stmt_;

	int sqlQueryType_;
	int stmtHandle_;
	int estimatedCost_;
	boolean prepare2 = false;

	// used for SPJ transaction
	static Class LmUtility_class_ = null;
	static java.lang.reflect.Method LmUtility_getTransactionId_ = null;

	PrepareReply pr_;

	// ----------------------------------------------------------------------
	InterfaceStatement(TrafT4Statement stmt) throws SQLException {
		this.ic_ = ((TrafT4Connection) stmt.getConnection()).getServerHandle();
		queryTimeout_ = stmt.queryTimeout_;
		stmtLabel_ = stmt.stmtLabel_;
		cursorName_ = stmt.cursorName_;
		t4statement_ = new T4Statement(this);
		stmt_ = stmt;
		sqlQueryType_ = TRANSPORT.SQL_QUERY_TYPE_NOT_SET;
	};

	public int getSqlQueryType() {
		return sqlQueryType_;
	}

	private String convertDateFormat(String dt) {
		String tokens[] = dt.split("[/]", 3);

		if (tokens.length != 3) {
			return dt;
		}
		StringBuffer sb = new StringBuffer();
		sb.append(tokens[0]).append("-").append(tokens[1]).append("-").append(tokens[2]);
		return sb.toString();
	}

	// ----------------------------------------------------------------------
	/**
	 * This method will take an object and convert it to the approperite format
	 * for sending to TrafT4.
	 * 
	 * @param locale
	 *            The locale for this operation
	 * @param pstmt
	 *            The prepared statement associated with the object
	 * @param paramValue
	 *            The object to convert
	 * @param paramNumber
	 *            The parameter number associated with this object
	 * @param values
	 *            The array to place the converted object into
	 */
	void convertObjectToSQL2(Locale locale, TrafT4Statement pstmt, Object paramValue, int paramRowCount, int paramNumber,
			byte[] values, int rowNumber) throws SQLException {
		byte[] tmpBarray = null;
		int i;
		BigDecimal tmpbd;
		
		int precision = pstmt.inputDesc_[paramNumber].precision_;
		int scale = pstmt.inputDesc_[paramNumber].scale_;
		int sqlDatetimeCode = pstmt.inputDesc_[paramNumber].sqlDatetimeCode_;
		int FSDataType = pstmt.inputDesc_[paramNumber].fsDataType_;
		int OdbcDataType = pstmt.inputDesc_[paramNumber].dataType_;
		int maxLength = pstmt.inputDesc_[paramNumber].sqlOctetLength_;
		int dataType = pstmt.inputDesc_[paramNumber].sqlDataType_;
		int dataCharSet = pstmt.inputDesc_[paramNumber].sqlCharset_;
		int dataLen;

		// setup the offsets
		int noNullValue = pstmt.inputDesc_[paramNumber].noNullValue_;
		int nullValue = pstmt.inputDesc_[paramNumber].nullValue_;
		int dataLength = pstmt.inputDesc_[paramNumber].maxLen_;

        int dataOffset = 2;
        boolean shortLength = false;
        if (dataType == InterfaceResultSet.SQLTYPECODE_VARCHAR_WITH_LENGTH) {
            shortLength = precision < Math.pow(2, 15);
            dataOffset = ((shortLength) ? 2 : 4);
            dataLength += dataOffset;

            if (dataLength % 2 != 0)
                dataLength++;
        } else if (dataType == InterfaceResultSet.SQLTYPECODE_BLOB || dataType == InterfaceResultSet.SQLTYPECODE_CLOB) {
            shortLength = false;
            dataOffset = 4;
            dataLength += dataOffset;

            if (dataLength % 2 != 0)
                dataLength++;
        }

		if (nullValue != -1)
			nullValue = (nullValue * paramRowCount) + (rowNumber * 2);

        noNullValue = (noNullValue * paramRowCount) + (rowNumber * dataLength);
		if (paramValue == null) {
			if (nullValue == -1) {
				throw TrafT4Messages.createSQLException(pstmt.connection_.props_, locale,
						"null_parameter_for_not_null_column", new Integer(paramNumber));
			}

			// values[nullValue] = -1;
			Bytes.insertShort(values, nullValue, (short) -1, this.ic_.getByteSwap());
			return;
		}

		switch (dataType) {
		case InterfaceResultSet.SQLTYPECODE_CHAR:
			if (paramValue == null) {
				// Note for future optimization. We can probably remove the next
				// line,
				// because the array is already initialized to 0.
				Bytes.insertShort(values, noNullValue, (short) 0, this.ic_.getByteSwap());
            } else if (paramValue instanceof byte[] || paramValue instanceof String) {
                String charSet = "";

                try {
                    if (this.ic_.getISOMapping() == InterfaceUtilities.SQLCHARSETCODE_ISO88591
                            && !this.ic_.getEnforceISO() && dataCharSet == InterfaceUtilities.SQLCHARSETCODE_ISO88591)
                        charSet = ic_.t4props_.getISO88591();
                    else {
                        if (dataCharSet == InterfaceUtilities.SQLCHARSETCODE_UNICODE && this.ic_.getByteSwap())
                            charSet = "UTF-16LE";
                        else
                            charSet = InterfaceUtilities.getCharsetName(dataCharSet);
                    }
                    if (paramValue instanceof byte[]) {
                        tmpBarray = (new String((byte[]) paramValue)).getBytes(charSet);
                    } else {
                        tmpBarray = (((String) paramValue)).getBytes(charSet);
                    }
                } catch (Exception e) {
                    throw TrafT4Messages.createSQLException(pstmt.connection_.props_, locale, "unsupported_encoding",
                            charSet);
                }
            } // end if (paramValue instanceof String)
			else {
				throw TrafT4Messages.createSQLException(pstmt.connection_.props_, locale, "invalid_parameter_value",
						"CHAR data should be either bytes or String for column: " + paramNumber);
			}

			//
			// We now have a byte array containing the parameter
			//

			dataLen = tmpBarray.length;
			if (maxLength >= dataLen) {
				System.arraycopy(tmpBarray, 0, values, noNullValue, dataLen);
				// Blank pad for rest of the buffer
				if (maxLength > dataLen) {
					if (dataCharSet == InterfaceUtilities.SQLCHARSETCODE_UNICODE) {
						// pad with Unicode spaces (0x00 0x32)
						int i2 = dataLen;
						while (i2 < maxLength) {
							values[noNullValue + i2] = (byte) ' ';
							values[noNullValue + (i2 + 1)] = (byte) 0 ;
							i2 = i2 + 2;
						}
					} else {
						Arrays.fill(values, (noNullValue + dataLen), (noNullValue + maxLength), (byte) ' ');
					}
				}
			} else {
				throw TrafT4Messages.createSQLException(pstmt.connection_.props_, locale, "invalid_string_parameter",
						"CHAR input data is longer than the length for column: " + paramNumber);
			}

			break;
		case InterfaceResultSet.SQLTYPECODE_VARCHAR:
			if (paramValue instanceof byte[]) {
				tmpBarray = (byte[]) paramValue;
			} else if (paramValue instanceof String) {
				String charSet = "";

				try {
					if (this.ic_.getISOMapping() == InterfaceUtilities.SQLCHARSETCODE_ISO88591
							&& !this.ic_.getEnforceISO() && dataCharSet == InterfaceUtilities.SQLCHARSETCODE_ISO88591)
						charSet = ic_.t4props_.getISO88591();
					else
					{
						if(dataCharSet == InterfaceUtilities.SQLCHARSETCODE_UNICODE && this.ic_.getByteSwap())
							charSet = "UTF-16LE";
						else
							charSet = InterfaceUtilities.getCharsetName(dataCharSet);
					}
					tmpBarray = ((String) paramValue).getBytes(charSet);
				} catch (Exception e) {
					throw TrafT4Messages.createSQLException(pstmt.connection_.props_, locale, "unsupported_encoding",
							charSet);
				}

			} // end if (paramValue instanceof String)
			else {
				throw TrafT4Messages.createSQLException(pstmt.connection_.props_, locale, "invalid_parameter_value",
						"VARCHAR data should be either bytes or String for column: " + paramNumber);
			}

			dataLen = tmpBarray.length;
			if (maxLength > dataLen) {
				Bytes.insertShort(values, noNullValue, (short) dataLen, this.ic_.getByteSwap());
				System.arraycopy(tmpBarray, 0, values, noNullValue + 2, dataLen);
			} else {
				throw TrafT4Messages.createSQLException(pstmt.connection_.props_, locale, "invalid_parameter_value",
						"VARCHAR input data is longer than the length for column: " + paramNumber);
			}
			break;
		case InterfaceResultSet.SQLTYPECODE_DATETIME:
			Date tmpdate = null;
			switch (sqlDatetimeCode) {
			case InterfaceResultSet.SQLDTCODE_DATE:
				try {
					if (((String) paramValue)
							.matches("(\\d{4}-\\d{1,2}-\\d{1,2})|(\\d{1,2}\\.\\d{1,2}\\.\\d{4})|(\\d{1,2}/\\d{1,2}/\\d{4})")) {
						tmpdate = Date.valueOf((String) ((String) paramValue)
								.replaceFirst("(\\d{1,2})\\.(\\d{1,2})\\.(\\d{4})",	"$3-$2-$1")
								.replaceFirst("(\\d{1,2})/(\\d{1,2})/(\\d{4})",	"$3-$1-$2"));
					}else{
						throw new IllegalArgumentException();
					}
				} catch (IllegalArgumentException iex) {
					throw TrafT4Messages
							.createSQLException(
									pstmt.connection_.props_,
									locale,
									"invalid_parameter_value",
									"["+paramValue+"] Date format is incorrect or date value is invalide. "
											+ "  Supported format: YYYY-MM-DD, MM/DD/YYYY, DD.MM.YYYY");
				}
				try {
					byte[] temp1 = tmpdate.toString().getBytes("ASCII");
					System.arraycopy(temp1, 0, values, noNullValue, temp1.length);
				} catch (java.io.UnsupportedEncodingException e) {
					Object[] messageArguments = new Object[1];
					messageArguments[0] = e.getMessage();
					throw TrafT4Messages.createSQLException(pstmt.connection_.props_, locale, "unsupported_encoding",
							messageArguments);
				}
				break;
			case InterfaceResultSet.SQLDTCODE_TIMESTAMP:
				Timestamp tmpts = null;
				try {
					String tmpStr = (String) paramValue;
					String pattern = "(\\d{4}-\\d{1,2}-\\d{1,2}):(.*)";
					if(tmpStr != null && tmpStr.matches(pattern)) {
						tmpStr = tmpStr.replaceFirst(pattern, "$1 $2");
					}
					tmpts = Timestamp.valueOf(tmpStr);
				} catch (IllegalArgumentException iex) {
					throw TrafT4Messages.createSQLException(pstmt.connection_.props_, locale, "invalid_parameter_value",
							"Timestamp data format is incorrect for column: " + paramNumber + " = " + paramValue);
				}

				// ODBC precision is nano secs. JDBC precision is micro secs
				// so substract 3 from ODBC precision.
				maxLength = maxLength - 3;
				try {
					tmpBarray = tmpts.toString().getBytes("ASCII");
				} catch (java.io.UnsupportedEncodingException e) {
					Object[] messageArguments = new Object[1];
					messageArguments[0] = e.getMessage();
					throw TrafT4Messages.createSQLException(pstmt.connection_.props_, locale, "unsupported_encoding",
							messageArguments);
				}
				dataLen = tmpBarray.length;

				if (maxLength > dataLen) {
					System.arraycopy(tmpBarray, 0, values, noNullValue, dataLen);

					// Don't know when we need this. padding blanks. Legacy??
					Arrays.fill(values, (noNullValue + dataLen), (noNullValue + maxLength), (byte) ' ');
				} else {
					System.arraycopy(tmpBarray, 0, values, noNullValue, maxLength);
				}
				break;
			case InterfaceResultSet.SQLDTCODE_TIME:
				// If the OdbcDataType is equal to Types.Other, that means
				// that this is HOUR_TO_FRACTION and should be treated
				// as a Type.Other --> see in SQLDesc.java
				if (OdbcDataType != java.sql.Types.OTHER) // do the processing
				// for TIME
				{
					Time tmptime;
					try {
						if (paramValue instanceof byte[]) {
							tmptime = Time.valueOf(new String((byte[]) paramValue, "ASCII"));
						} else {
							tmptime = Time.valueOf(paramValue.toString());
						}
						byte[] tempb1 = tmptime.toString().getBytes("ASCII");
						System.arraycopy(tempb1, 0, values, noNullValue, tempb1.length);
					} catch (IllegalArgumentException iex) {
						throw TrafT4Messages.createSQLException(pstmt.connection_.props_, locale,
								"invalid_parameter_value", "Time data format is incorrect for column: " + paramNumber
										+ " = " + paramValue);
					} catch (java.io.UnsupportedEncodingException e) {
						Object[] messageArguments = new Object[1];
						messageArguments[0] = e.getMessage();
						throw TrafT4Messages.createSQLException(pstmt.connection_.props_, locale, "unsupported_encoding",
								messageArguments);
					}
					break;
				} else {
					// TrafT4Desc.SQLDTCODE_HOUR_TO_FRACTION data type!!!
					// let the next case structure handle it
				}
			case TrafT4Desc.SQLDTCODE_YEAR:
			case TrafT4Desc.SQLDTCODE_YEAR_TO_MONTH:
			case TrafT4Desc.SQLDTCODE_MONTH:
			case TrafT4Desc.SQLDTCODE_MONTH_TO_DAY:
			case TrafT4Desc.SQLDTCODE_DAY:
			case TrafT4Desc.SQLDTCODE_HOUR:
			case TrafT4Desc.SQLDTCODE_HOUR_TO_MINUTE:
			case TrafT4Desc.SQLDTCODE_MINUTE:
			case TrafT4Desc.SQLDTCODE_MINUTE_TO_SECOND:
				// case TrafT4Desc.SQLDTCODE_MINUTE_TO_FRACTION:
			case TrafT4Desc.SQLDTCODE_SECOND:
				// case TrafT4Desc.SQLDTCODE_SECOND_TO_FRACTION:
			case TrafT4Desc.SQLDTCODE_YEAR_TO_HOUR:
			case TrafT4Desc.SQLDTCODE_YEAR_TO_MINUTE:
			case TrafT4Desc.SQLDTCODE_MONTH_TO_HOUR:
			case TrafT4Desc.SQLDTCODE_MONTH_TO_MINUTE:
			case TrafT4Desc.SQLDTCODE_MONTH_TO_SECOND:
				// case TrafT4Desc.SQLDTCODE_MONTH_TO_FRACTION:
			case TrafT4Desc.SQLDTCODE_DAY_TO_HOUR:
			case TrafT4Desc.SQLDTCODE_DAY_TO_MINUTE:
			case TrafT4Desc.SQLDTCODE_DAY_TO_SECOND:
				// case TrafT4Desc.SQLDTCODE_DAY_TO_FRACTION:
			default:
				if (paramValue instanceof String) {
					try {
						tmpBarray = ((String) paramValue).getBytes("ASCII");
					} catch (Exception e) {
						throw TrafT4Messages.createSQLException(pstmt.connection_.props_, locale, "unsupported_encoding",
								"ASCII");
					}
				} else if (paramValue instanceof byte[]) {
					tmpBarray = (byte[]) paramValue;
				} else {
					throw TrafT4Messages.createSQLException(pstmt.connection_.props_, locale,
							"invalid_cast_specification", "DATETIME data should be either bytes or String for column: "
									+ paramNumber);
				}
				dataLen = tmpBarray.length;
				if (maxLength == dataLen) {
					System.arraycopy(tmpBarray, 0, values, noNullValue, maxLength);
				} else if (maxLength > dataLen) {
					System.arraycopy(tmpBarray, 0, values, noNullValue, dataLen);

					// Don't know when we need this. padding blanks. Legacy??
					Arrays.fill(values, (noNullValue + dataLen), (noNullValue + maxLength), (byte) ' ');
				} else {
					throw TrafT4Messages.createSQLException(pstmt.connection_.props_, locale, "invalid_parameter_value",
							"DATETIME data longer than column length: " + paramNumber);
				}
				break;
			}
			break;
		case InterfaceResultSet.SQLTYPECODE_INTERVAL:
			if (paramValue instanceof byte[]) {
				tmpBarray = (byte[]) paramValue;
			} else if (paramValue instanceof String) {
				try {
					tmpBarray = ((String) paramValue).getBytes("ASCII");
				} catch (Exception e) {
					throw TrafT4Messages.createSQLException(pstmt.connection_.props_, locale, "unsupported_encoding",
							"ASCII");
				}
			} else {
				throw TrafT4Messages.createSQLException(pstmt.connection_.props_, locale, "invalid_cast_specification",
						"INTERVAL data should be either bytes or String for column: " + paramNumber);
			}

			dataLen = tmpBarray.length;
			if (maxLength >= dataLen) {
				dataLen = tmpBarray.length;
				if (maxLength == dataLen) {
					System.arraycopy(tmpBarray, 0, values, noNullValue, maxLength);
				} else if (maxLength > dataLen) {
					System.arraycopy(tmpBarray, 0, values, noNullValue, dataLen);

					// Don't know when we need this. padding blanks. Legacy??
					Arrays.fill(values, (noNullValue + dataLen), (noNullValue + maxLength), (byte) ' ');
				}
			} else {
				throw TrafT4Messages.createSQLException(pstmt.connection_.props_, locale, "invalid_parameter_value",
						"INTERVAL data longer than column length: " + paramNumber);
			}

			break;
		case InterfaceResultSet.SQLTYPECODE_VARCHAR_WITH_LENGTH:
		case InterfaceResultSet.SQLTYPECODE_VARCHAR_LONG:

			if (paramValue instanceof byte[]) {
				tmpBarray = (byte[]) paramValue;
			} else if (paramValue instanceof String) {
				String charSet = "";

				try {
					if (this.ic_.getISOMapping() == InterfaceUtilities.SQLCHARSETCODE_ISO88591
							&& !this.ic_.getEnforceISO() && dataCharSet == InterfaceUtilities.SQLCHARSETCODE_ISO88591)
						charSet = ic_.t4props_.getISO88591();
					else
					{
						if(dataCharSet == InterfaceUtilities.SQLCHARSETCODE_UNICODE && this.ic_.getByteSwap())
							charSet = "UTF-16LE";
						else
							charSet = InterfaceUtilities.getCharsetName(dataCharSet);
					}
					tmpBarray = ((String) paramValue).getBytes(charSet);
				} catch (Exception e) {
					throw TrafT4Messages.createSQLException(pstmt.connection_.props_, locale, "unsupported_encoding",
							charSet);
				}
			} // end if (paramValue instanceof String)
			else {
				throw TrafT4Messages.createSQLException(pstmt.connection_.props_, locale, "invalid_cast_specification",
						"VARCHAR data should be either bytes or String for column: " + paramNumber);
			}

			dataLen = tmpBarray.length;
			if (maxLength > (dataLen + dataOffset)) { 
				maxLength = dataLen + dataOffset;

                                if (shortLength) {
				   System.arraycopy(Bytes.createShortBytes((short) dataLen, this.ic_.getByteSwap()), 0, values, noNullValue, dataOffset);
                                } else {
				   System.arraycopy(Bytes.createIntBytes((int) dataLen, this.ic_.getByteSwap()), 0, values, noNullValue, dataOffset);
                                }
				System.arraycopy(tmpBarray, 0, values, (noNullValue + dataOffset), dataLen);
			} else {
				throw TrafT4Messages.createSQLException(pstmt.connection_.props_, locale, "invalid_string_parameter",
						"VARCHAR data longer than column length: " + paramNumber);
			}
			break;
		case InterfaceResultSet.SQLTYPECODE_BLOB:
			if (paramValue instanceof InputStream) {
				InputStream is = (InputStream)paramValue;
				dataLen = 0;
				try {
					int bytesRead = is.read(values, noNullValue + dataOffset, maxLength - dataOffset);
					dataLen = bytesRead;
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.arraycopy(Bytes.createIntBytes(dataLen, this.ic_.getByteSwap()), 0, values, noNullValue, dataOffset);
			}
			else {
				tmpBarray = (byte[])paramValue;
				dataLen = tmpBarray.length;
				dataOffset = 4;
	            if (maxLength > dataLen) {
	                System.arraycopy(Bytes.createIntBytes(dataLen, this.ic_.getByteSwap()), 0, values, noNullValue, dataOffset);
	                System.arraycopy(tmpBarray, 0, values, (noNullValue + dataOffset), dataLen);
	            } else {
	                throw TrafT4Messages.createSQLException(pstmt.connection_.props_, locale, "23",
	                        "BLOB input data is longer than the length for column: " + paramNumber);
	            }
			}
			break;
		case InterfaceResultSet.SQLTYPECODE_BINARY:
		case InterfaceResultSet.SQLTYPECODE_VARBINARY:
			if (paramValue instanceof InputStream) {
				InputStream is = (InputStream)paramValue;
				dataLen = 0;
				try {
					int bytesRead = is.read(values, noNullValue + dataOffset, maxLength - dataOffset);
					dataLen = bytesRead;
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.arraycopy(Bytes.createIntBytes(dataLen, this.ic_.getByteSwap()), 0, values, noNullValue, dataOffset);
			}
			else {
				tmpBarray = (byte[])paramValue;
				dataLen = tmpBarray.length;
				dataOffset = 4;
	            if (maxLength > dataLen) {
	                System.arraycopy(Bytes.createIntBytes(dataLen, this.ic_.getByteSwap()), 0, values, noNullValue, dataOffset);
	                System.arraycopy(tmpBarray, 0, values, (noNullValue + dataOffset), dataLen);
	            } else {
	                throw TrafT4Messages.createSQLException(pstmt.connection_.props_, locale, "23",
	                        "BINARY input data is longer than the length for column: " + paramNumber);
	            }
			}
			break;

		case InterfaceResultSet.SQLTYPECODE_CLOB:
			String charSet = "";

			try {
				if (this.ic_.getISOMapping() == InterfaceUtilities.SQLCHARSETCODE_ISO88591
						&& !this.ic_.getEnforceISO() && dataCharSet == InterfaceUtilities.SQLCHARSETCODE_ISO88591)
					charSet = ic_.t4props_.getISO88591();
				else
				{
					if(dataCharSet == InterfaceUtilities.SQLCHARSETCODE_UNICODE && this.ic_.getByteSwap())
						charSet = "UTF-16LE";
					else
						charSet = InterfaceUtilities.getCharsetName(dataCharSet);
				}
				tmpBarray = ((String) paramValue).getBytes("UTF-8");
			} catch (Exception e) {
				throw TrafT4Messages.createSQLException(pstmt.connection_.props_, locale, "unsupported_encoding",
						charSet);
			}
			dataLen = tmpBarray.length;
			dataOffset = 4;
			if (maxLength > dataLen) {
			    System.arraycopy(Bytes.createIntBytes(dataLen, this.ic_.getByteSwap()), 0, values, noNullValue, dataOffset);
			    System.arraycopy(tmpBarray, 0, values, (noNullValue + dataOffset), dataLen);
			}
			
			break;
		case InterfaceResultSet.SQLTYPECODE_INTEGER:
			tmpbd = Utility.getBigDecimalValue(locale, paramValue);
			if (scale > 0) {
				tmpbd = tmpbd.movePointRight(scale);
			}

			// data truncation check
			if (pstmt.roundingMode_ == BigDecimal.ROUND_UNNECESSARY) {
				Utility.checkLongTruncation(paramNumber, tmpbd);

			}
			Utility.checkIntegerBoundary(locale, tmpbd);

			// check boundary condition for Numeric.
			Utility.checkDecimalBoundary(locale, tmpbd, precision);

			Bytes.insertInt(values, noNullValue, tmpbd.intValue(), this.ic_.getByteSwap());
			break;
		case InterfaceResultSet.SQLTYPECODE_INTEGER_UNSIGNED:
			tmpbd = Utility.getBigDecimalValue(locale, paramValue);
			if (scale > 0) {
				tmpbd = tmpbd.movePointRight(scale);
			}

			// data truncation check
			if (pstmt.roundingMode_ == BigDecimal.ROUND_UNNECESSARY) {
				Utility.checkLongTruncation(paramNumber, tmpbd);

				// range checking
			}
			Utility.checkUnsignedIntegerBoundary(locale, tmpbd);

			// check boundary condition for Numeric.
			Utility.checkDecimalBoundary(locale, tmpbd, precision);

			Bytes.insertInt(values, noNullValue, tmpbd.intValue(), this.ic_.getByteSwap());
			break;

		case InterfaceResultSet.SQLTYPECODE_TINYINT:
			tmpbd = Utility.getBigDecimalValue(locale, paramValue);
			if (scale > 0) {
				throw TrafT4Messages.createSQLException(pstmt.connection_.props_, locale, "invalid_parameter_value",
						"Cannot have scale for param: " + paramNumber);
                        }
                        
			Utility.checkSignedTinyintBoundary(locale, tmpbd);

			Bytes.insertShort(values, noNullValue, tmpbd.byteValueExact(), this.ic_.getByteSwap());

                        break;
		case InterfaceResultSet.SQLTYPECODE_TINYINT_UNSIGNED:
			tmpbd = Utility.getBigDecimalValue(locale, paramValue);
			if (scale > 0) {
				throw TrafT4Messages.createSQLException(pstmt.connection_.props_, locale, "invalid_parameter_value",
						"Cannot have scale for param: " + paramNumber);
                        }
                        
			Utility.checkUnsignedTinyintBoundary(locale, tmpbd);

			Bytes.insertShort(values, noNullValue, tmpbd.byteValue(), this.ic_.getByteSwap());
                        break;
		case InterfaceResultSet.SQLTYPECODE_SMALLINT:
			tmpbd = Utility.getBigDecimalValue(locale, paramValue);
			if (scale > 0) {
				tmpbd = tmpbd.movePointRight(scale);
			}

			// data truncation check
			if (pstmt.roundingMode_ == BigDecimal.ROUND_UNNECESSARY) {
				Utility.checkLongTruncation(paramNumber, tmpbd);

				// range checking
			}
			Utility.checkShortBoundary(locale, tmpbd);

			// check boundary condition for Numeric.
			Utility.checkDecimalBoundary(locale, tmpbd, precision);

			Bytes.insertShort(values, noNullValue, tmpbd.shortValue(), this.ic_.getByteSwap());
			break;
		case InterfaceResultSet.SQLTYPECODE_SMALLINT_UNSIGNED:
			tmpbd = Utility.getBigDecimalValue(locale, paramValue);
			if (scale > 0) {
				tmpbd = tmpbd.movePointRight(scale);
			}

			// data truncation check
			if (pstmt.roundingMode_ == BigDecimal.ROUND_UNNECESSARY) {
				Utility.checkLongTruncation(paramNumber, tmpbd);

				// range checking
			}

			Utility.checkUnsignedShortBoundary(locale, tmpbd);

			// check boundary condition for Numeric.
			Utility.checkDecimalBoundary(locale, tmpbd, precision);

			Bytes.insertShort(values, noNullValue, tmpbd.shortValue(), this.ic_.getByteSwap());
			break;
		case InterfaceResultSet.SQLTYPECODE_LARGEINT:
			tmpbd = Utility.getBigDecimalValue(locale, paramValue);

			if (scale > 0) {
				tmpbd = tmpbd.movePointRight(scale);

				// check boundary condition for Numeric.
			}
			Utility.checkLongBoundary(locale, tmpbd);
			Utility.checkDecimalBoundary(locale, tmpbd, precision);
			Bytes.insertLong(values, noNullValue, tmpbd.longValue(), this.ic_.getByteSwap());
			break;
		case InterfaceResultSet.SQLTYPECODE_LARGEINT_UNSIGNED:
			tmpbd = Utility.getBigDecimalValue(locale, paramValue);

			if (scale > 0) {
				tmpbd = tmpbd.movePointRight(scale);

				// check boundary condition for Numeric.
			}
			Utility.checkUnsignedLongBoundary(locale, tmpbd);
			Bytes.insertLong(values, noNullValue, tmpbd.longValue(), this.ic_.getByteSwap());
			break;
		case InterfaceResultSet.SQLTYPECODE_DECIMAL:
		case InterfaceResultSet.SQLTYPECODE_DECIMAL_UNSIGNED:

			// create an parameter with out "."
			try {
				tmpbd = Utility.getBigDecimalValue(locale, paramValue);
				if (scale > 0) {
					tmpbd = tmpbd.movePointRight(scale);

				}

				tmpbd = Utility.setScale(tmpbd, scale, pstmt.roundingMode_);

				// data truncation check.
				if (pstmt.roundingMode_ == BigDecimal.ROUND_UNNECESSARY) {
					Utility.checkLongTruncation(paramNumber, tmpbd);

					// get only the mantissa part
				}
				try {
					tmpBarray = String.valueOf(tmpbd.longValue()).getBytes("ASCII");
				} catch (java.io.UnsupportedEncodingException e) {
					Object[] messageArguments = new Object[1];
					messageArguments[0] = e.getMessage();
					throw TrafT4Messages.createSQLException(pstmt.connection_.props_, locale, "unsupported_encoding",
							messageArguments);
				}
			} catch (NumberFormatException nex) {
				throw TrafT4Messages.createSQLException(pstmt.connection_.props_, locale, "invalid_parameter_value",
						"DECIMAL data format incorrect for column: " + paramNumber + ". Error is: " + nex.getMessage());
			}

			dataLen = tmpBarray.length;

			// pad leading zero's if datalen < maxLength
			int desPos = 0;
			int srcPos = 0;
			boolean minus = false;

			// check if data is negative.
			if (tmpbd.signum() == -1) {
				minus = true;
				srcPos++;
				dataLen--;
			}

			// pad beginning 0 for empty space.
			int numOfZeros = maxLength - dataLen;

			// DataTruncation is happening.
			if (numOfZeros < 0) {
				throw TrafT4Messages.createSQLException(pstmt.connection_.props_, locale, "data_truncation_exceed", new int[]{dataLen, maxLength});
			}

			for (i = 0; i < numOfZeros; i++) {
				values[noNullValue + desPos] = (byte) '0';
				desPos = desPos + 1;
			}
			System.arraycopy(tmpBarray, srcPos, values, noNullValue + desPos, dataLen);

			// handling minus sign in decimal. OR -80 with the first byte for
			// minus
			if (minus) {
				values[noNullValue] = (byte) ((byte) (-80) | values[noNullValue]);
			}
			break;
		case InterfaceResultSet.SQLTYPECODE_REAL:
			tmpbd = Utility.getBigDecimalValue(locale, paramValue);
			Utility.checkFloatBoundary(locale, tmpbd);
			float fvalue = tmpbd.floatValue();
			int bits = Float.floatToIntBits(fvalue);

			Bytes.insertInt(values, noNullValue, bits, this.ic_.getByteSwap());
			break;
		case InterfaceResultSet.SQLTYPECODE_FLOAT:
			tmpbd = Utility.getBigDecimalValue(locale, paramValue);
			Utility.checkFloatBoundary(locale, tmpbd);
			Bytes.insertLong(values, noNullValue, Double.doubleToLongBits(tmpbd.doubleValue()), this.ic_.getByteSwap());
			break;
		case InterfaceResultSet.SQLTYPECODE_DOUBLE:
			tmpbd = Utility.getBigDecimalValue(locale, paramValue);
			Utility.checkDoubleBoundary(locale, tmpbd);
			Bytes.insertLong(values, noNullValue, Double.doubleToLongBits(tmpbd.doubleValue()), this.ic_.getByteSwap());
			break;
		case InterfaceResultSet.SQLTYPECODE_NUMERIC:
		case InterfaceResultSet.SQLTYPECODE_NUMERIC_UNSIGNED:
			tmpbd = Utility.getBigDecimalValue(locale, paramValue);
			byte[] b = InterfaceUtilities.convertBigDecimalToSQLBigNum(tmpbd, maxLength, scale);
			System.arraycopy(b, 0, values, noNullValue, maxLength);
			break;
		case InterfaceResultSet.SQLTYPECODE_BOOLEAN:
			tmpbd = Utility.getBigDecimalValue(locale, paramValue);

			Bytes.insertByte(values, noNullValue, tmpbd.byteValue());
			break;
		// You will not get this type, since server internally converts it
		// SMALLINT, INTERGER or LARGEINT
		case InterfaceResultSet.SQLTYPECODE_DECIMAL_LARGE:
		case InterfaceResultSet.SQLTYPECODE_DECIMAL_LARGE_UNSIGNED:
		case InterfaceResultSet.SQLTYPECODE_BIT:
		case InterfaceResultSet.SQLTYPECODE_BITVAR:
		case InterfaceResultSet.SQLTYPECODE_BPINT_UNSIGNED:
		default:
                    if (ic_.t4props_.t4Logger_.isLoggable(Level.FINEST) == true) {
                        Object p[] = T4LoggingUtilities.makeParams(stmt_.connection_.props_, locale, pstmt, paramValue,
                                                                   paramNumber);
                        String temp = "Restricted_Ddatatype_Error" + "datatype = " + dataType;
                        ic_.t4props_.t4Logger_.logp(Level.FINEST, "InterfaceStatementtt", "convertObjectToSQL222", temp, p);
                    }
                    
                    throw TrafT4Messages.createSQLException(pstmt.connection_.props_, locale, "restricted_data_type", null);
		}
		if (ic_.t4props_.t4Logger_.isLoggable(Level.FINEST) == true) {
			Object p[] = T4LoggingUtilities
					.makeParams(stmt_.connection_.props_, locale, pstmt, paramValue, paramNumber);
			String temp = "datatype = " + dataType;
			ic_.t4props_.t4Logger_.logp(Level.FINEST, "InterfaceStatement", "convertObjectToSQL2", temp, p);
		}

	} // end convertObjectToSQL2

	private SQLWarningOrError[] mergeErrors(SQLWarningOrError[] client, SQLWarningOrError[] server) {
		SQLWarningOrError[] target = new SQLWarningOrError[client.length + server.length];

		int si = 0; // server index
		int ci = 0; // client index
		int ti = 0; // target index

		int sr; // server rowId
		int cr; // client rowId

		int so = 0; // server offset

		while (ci < client.length && si < server.length) {
			cr = client[ci].rowId;
			sr = server[si].rowId + so;

			if (cr <= sr || server[si].rowId == 0) {
				so++;
				target[ti++] = client[ci++];
			} else {
				server[si].rowId += so;
				target[ti++] = server[si++];
			}
		}

		// we only have one array left
		while (ci < client.length) {
			target[ti++] = client[ci++];
		}

		while (si < server.length) {
			if (server[si].rowId != 0)
				server[si].rowId += so;
			target[ti++] = server[si++];
		}

		return target;
	}

	SQL_DataValue_def fillInSQLValues2(Locale locale, TrafT4Statement stmt, int paramRowCount, int paramCount,
			Object[] paramValues, ArrayList clientErrors) throws SQLException

	{
		SQL_DataValue_def dataValue = new SQL_DataValue_def();

		if (paramRowCount == 0 && paramValues != null && paramValues.length > 0)
			paramRowCount = 1; // fake a single row if we are doing inputParams
		// for an SPJ

		// TODO: we should really figure out WHY this could happen
		if (stmt.inputParamsLength_ < 0) {
			dataValue.buffer = new byte[0];
			dataValue.length = 0;
		} else {
			int bufLen = stmt.inputParamsLength_ * paramRowCount;

			dataValue.buffer = new byte[bufLen];


			for (int row = 0; row < paramRowCount; row++) {
				for (int col = 0; col < paramCount; col++) {
					try {
                       convertObjectToSQL2(locale, stmt, paramValues[row * paramCount + col], paramRowCount, col,
								dataValue.buffer, row - clientErrors.size());
					} catch (TrafT4Exception e) {
						if (paramRowCount == 1) // for single rows we need to
							// throw immediately
							throw e;

						clientErrors.add(new SQLWarningOrError(row + 1, e.getErrorCode(), e.getMessage(), e
								.getSQLState()));
						break; // skip the rest of the row
					}
				}
			}

			// fix the column offsets if we had errors
			if (clientErrors.size() > 0) {
				int oldOffset;
				int newOffset;
				int noNullValue;
				int nullValue;
				int colLength;
				int dataType;

				for (int i = 1; i < paramCount; i++) // skip the first col
				{
					noNullValue = stmt.inputDesc_[i].noNullValue_;
					nullValue = stmt.inputDesc_[i].nullValue_;
					colLength = stmt.inputDesc_[i].maxLen_;
					dataType = stmt.inputDesc_[i].dataType_;
					if (dataType == InterfaceResultSet.SQLTYPECODE_VARCHAR_WITH_LENGTH
							|| dataType == InterfaceResultSet.SQLTYPECODE_BLOB
							|| dataType == InterfaceResultSet.SQLTYPECODE_CLOB
							|| dataType == InterfaceResultSet.SQLTYPECODE_VARCHAR_LONG
							|| dataType == InterfaceResultSet.SQLTYPECODE_VARCHAR) {
                                                boolean shortLength = colLength < Math.pow(2, 15);
                                                int dataOffset = ((shortLength) ? 2 : 4);
                                                colLength += dataOffset;

						if (colLength % 2 != 0)
							colLength++;
					}

					if (nullValue != -1) {
						oldOffset = nullValue * paramRowCount;
						newOffset = oldOffset - (nullValue * clientErrors.size());
						System.arraycopy(dataValue.buffer, oldOffset, dataValue.buffer, newOffset,
								2 * (paramRowCount - clientErrors.size()));
					}

					oldOffset = noNullValue * paramRowCount;
					newOffset = oldOffset - (noNullValue * clientErrors.size());
					System.arraycopy(dataValue.buffer, oldOffset, dataValue.buffer, newOffset, colLength
							* (paramRowCount - clientErrors.size()));
				}
			}

			dataValue.length = stmt.inputParamsLength_ * (paramRowCount - clientErrors.size());
		}
		return dataValue;
	}

	// -------------------------------------------------------------
	short getSqlStmtType(String str) {
		short rt1 = TRANSPORT.TYPE_UNKNOWN;
		switch (sqlQueryType_) {
			case TRANSPORT.SQL_SELECT_UNIQUE:
			case TRANSPORT.SQL_SELECT_NON_UNIQUE:
				rt1 = TRANSPORT.TYPE_SELECT;
				break;
			case TRANSPORT.SQL_INSERT_UNIQUE:
			case TRANSPORT.SQL_INSERT_NON_UNIQUE:
			case TRANSPORT.SQL_INSERT_RWRS:
				if (stmt_ .inputDesc_ != null && stmt_.inputDesc_.length > 0)
					rt1 = TRANSPORT.TYPE_INSERT_PARAM;
				else
					rt1 = TRANSPORT.TYPE_INSERT;
				break;
			case TRANSPORT.SQL_UPDATE_UNIQUE:
			case TRANSPORT.SQL_UPDATE_NON_UNIQUE:
				rt1 = TRANSPORT.TYPE_UPDATE;
				break;
			case TRANSPORT.SQL_DELETE_UNIQUE:
			case TRANSPORT.SQL_DELETE_NON_UNIQUE:
				rt1 = TRANSPORT.TYPE_DELETE;
				break;
			case TRANSPORT.SQL_CALL_NO_RESULT_SETS:
			case TRANSPORT.SQL_CALL_WITH_RESULT_SETS:
				rt1 = TRANSPORT.TYPE_CALL;
				break;
			default:
				break;
		}
		return rt1;
	} // end getSqlStmtType

	// -------------------------------------------------------------
	long getRowCount() {
		return rowCount_;
	}

	// -------------------------------------------------------------
	void setRowCount(long rowCount) {
		if (rowCount < 0) {
			rowCount_ = -1;
		} else {
			rowCount_ = rowCount;
		}
	}

	// -------------------------------------------------------------
	static TrafT4Desc[] NewDescArray(SQLItemDescList_def desc) {
		int index;
		TrafT4Desc[] trafT4DescArray;
		SQLItemDesc_def SQLDesc;

		if (desc.list == null || desc.list.length == 0) {
			return null;
		}

		trafT4DescArray = new TrafT4Desc[desc.list.length];

		for (index = 0; index < desc.list.length; index++) {
			SQLDesc = desc.list[index];
			boolean nullInfo = (((new Byte(SQLDesc.nullInfo)).shortValue()) == 1) ? true : false;
			boolean signType = (((new Byte(SQLDesc.signType)).shortValue()) == 1) ? true : false;
			trafT4DescArray[index] = new TrafT4Desc(SQLDesc.dataType, (short) SQLDesc.datetimeCode, SQLDesc.maxLen,
					SQLDesc.precision, SQLDesc.scale, nullInfo, SQLDesc.colHeadingNm, signType, SQLDesc.ODBCDataType,
					SQLDesc.ODBCPrecision, SQLDesc.SQLCharset, SQLDesc.ODBCCharset, SQLDesc.CatalogName,
					SQLDesc.SchemaName, SQLDesc.TableName, SQLDesc.dataType, SQLDesc.intLeadPrec, SQLDesc.paramMode);
		}
		return trafT4DescArray;
	}

	// -------------------------------------------------------------
	static TrafT4Desc[] NewDescArray(Descriptor2[] descArray) {
		int index;
		TrafT4Desc[] trafT4DescArray;
		Descriptor2 desc;

		if (descArray == null || descArray.length == 0) {
			return null;
		}

		trafT4DescArray = new TrafT4Desc[descArray.length];

		for (index = 0; index < descArray.length; index++) {
			desc = descArray[index];
			boolean nullInfo = false;
			boolean signType = false;

			if (desc.nullInfo_ != 0) {
				nullInfo = true;
			}
			if (desc.signed_ != 0) {
				signType = true;

			}
			trafT4DescArray[index] = new TrafT4Desc(desc.noNullValue_, desc.nullValue_, desc.version_, desc.dataType_,
					(short) desc.datetimeCode_, desc.maxLen_, (short) desc.precision_, (short) desc.scale_, nullInfo,
					signType, desc.odbcDataType_, desc.odbcPrecision_, desc.sqlCharset_, desc.odbcCharset_,
					desc.colHeadingNm_, desc.tableName_, desc.catalogName_, desc.schemaName_, desc.headingName_,
					desc.intLeadPrec_, desc.paramMode_, desc.dataType_, desc.getRowLength());
		}
		return trafT4DescArray;
	}

	// -------------------------------------------------------------
	// Interface methods
	void executeDirect(int queryTimeout, TrafT4Statement stmt) throws SQLException {
		short executeAPI = stmt.getOperationID();
		byte[] messageBuffer = stmt.getOperationBuffer();
		GenericReply gr = null;

		gr = t4statement_.ExecuteGeneric(executeAPI, messageBuffer);
		stmt.operationReply_ = gr.replyBuffer;

		if (ic_.t4props_.t4Logger_.isLoggable(Level.FINEST) == true) {
			Object p[] = T4LoggingUtilities.makeParams(stmt_.connection_.props_, queryTimeout, stmt);
			String temp = "Exiting ExecDirect.";
			ic_.t4props_.t4Logger_.logp(Level.FINEST, "InterfaceStatement", "executeDirect", temp, p);
		}
	} // end executeDirect

	// --------------------------------------------------------------------------
	int close() throws SQLException {
		int rval = 0;
		CloseReply cry_ = null;
		ic_.isConnectionOpen();
		if (ic_.t4props_.t4Logger_.isLoggable(Level.FINEST) == true) {
			Object p[] = T4LoggingUtilities.makeParams(stmt_.connection_.props_);
			String temp = "Closing = " + stmtLabel_;
			ic_.t4props_.t4Logger_.logp(Level.FINEST, "InterfaceStatement", "close", temp, p);
		}

		cry_ = t4statement_.Close();
		switch (cry_.m_p1.exception_nr) {
		case TRANSPORT.CEE_SUCCESS:

			// ignore the SQLWarning for the static close
			break;
		case odbc_SQLSvc_Close_exc_.odbc_SQLSvc_Close_SQLError_exn_:
			TrafT4Messages.throwSQLException(stmt_.connection_.props_, cry_.m_p1.SQLError);
		default:
			throw TrafT4Messages.createSQLException(stmt_.connection_.props_, ic_.getLocale(), "ids_unknown_reply_error",
					null);
		} // end switch

		return cry_.m_p2; // rowsAffected
	} // end close

	// --------------------------------------------------------------------------
	void cancel() throws SQLException {
		ic_.cancel();
	}

	// --------------------------------------------------------------------------
	// Interface methods for prepared statement
	void prepare(String sql, int queryTimeout, TrafT4PreparedStatement pstmt) throws SQLException {
		int sqlAsyncEnable = 0;
		this.stmtType_ = this.EXTERNAL_STMT;
		int stmtLabelCharset = 1;
		String cursorName = pstmt.cursorName_;
		int cursorNameCharset = 1;
		String moduleName = pstmt.moduleName_;
		int moduleNameCharset = 1;
		long moduleTimestamp = pstmt.moduleTimestamp_;
		String sqlString = sql;
		int sqlStringCharset = 1;
		String stmtOptions = "";
		int maxRowsetSize = pstmt.getMaxRows();

		byte[] txId;

//3196 - NDCS transaction for SPJ	
//		if (ic_.t4props_.getSPJEnv())
//			txId = getUDRTransaction(this.ic_.getByteSwap());
//		else
//			txId = Bytes.createIntBytes(0, false);
		txId = Bytes.createIntBytes(0, false);

		PrepareReply pr = t4statement_.Prepare(sqlAsyncEnable, (short) this.stmtType_, this.sqlStmtType_,
				pstmt.stmtLabel_, stmtLabelCharset, cursorName, cursorNameCharset, moduleName, moduleNameCharset,
				moduleTimestamp, sqlString, sqlStringCharset, stmtOptions, maxRowsetSize, txId);

		pr_ = pr;
		this.sqlQueryType_ = pr.sqlQueryType;
		this.sqlStmtType_ = getSqlStmtType(sqlString);

		switch (pr.returnCode) {
		case TRANSPORT.SQL_SUCCESS:
		case TRANSPORT.SQL_SUCCESS_WITH_INFO:
			TrafT4Desc[] OutputDesc = InterfaceStatement.NewDescArray(pr.outputDesc);
			TrafT4Desc[] InputDesc = InterfaceStatement.NewDescArray(pr.inputDesc);
			pstmt.setPrepareOutputs2(InputDesc, OutputDesc, pr.inputNumberParams, pr.outputNumberParams,
					pr.inputParamLength, pr.outputParamLength, pr.inputDescLength, pr.outputDescLength);

			if (pr.errorList != null && pr.errorList.length > 0) {
				TrafT4Messages.setSQLWarning(stmt_.connection_.props_, pstmt, pr.errorList);
			}

			this.stmtHandle_ = pr.stmtHandle;

			break;

		case odbc_SQLSvc_Prepare_exc_.odbc_SQLSvc_Prepare_SQLError_exn_:

		default:
			TrafT4Messages.throwSQLException(stmt_.connection_.props_, pr.errorList);
		}

		if (ic_.t4props_.t4Logger_.isLoggable(Level.FINEST) == true) {
			Object p[] = T4LoggingUtilities.makeParams(stmt_.connection_.props_, sql, queryTimeout, pstmt);
			String temp = "Exiting prepare...";
			ic_.t4props_.t4Logger_.logp(Level.FINEST, "InterfaceStatement", "prepare", temp, p);
		}
	};

	// used to keep the same transaction inside an SPJ. we call out to the UDR
	// server and use their transaction for all executes.
	byte[] getUDRTransaction(boolean swapBytes) throws SQLException {
		byte[] ret = null;

		try {
			// To get references to method
			InterfaceStatement.LmUtility_class_ = Class.forName("com.tandem.sqlmx.LmUtility");
			InterfaceStatement.LmUtility_getTransactionId_ = InterfaceStatement.LmUtility_class_.getMethod(
					"getTransactionId", new Class[] {});

			// To invoke the method
			short[] tId = (short[]) InterfaceStatement.LmUtility_getTransactionId_.invoke(null, new Object[] {});

			ret = new byte[tId.length * 2];

			for (int i = 0; i < tId.length; i++) {
				Bytes.insertShort(ret, i * 2, tId[i], swapBytes);
			}
		} catch (Exception e) {
			ic_.t4props_.t4Logger_.logp(Level.FINEST, "InterfaceStatement", "getUDRTransaction",
					"Error calling UDR for transaction id");

			String s = e.toString() + "\r\n";
			StackTraceElement[] st = e.getStackTrace();

			for (int i = 0; i < st.length; i++) {
				s += st[i].toString() + "\r\n";
			}

			throw new SQLException(s);
		}

		return ret;
	}

	// -------------------------------------------------------------------
	void execute(short executeAPI, int paramRowCount, int paramCount, Object[] paramValues, int queryTimeout
	// executeDirect
			, String sql, TrafT4Statement stmt

	) throws SQLException {
		cursorName_ = stmt.cursorName_;
		rowCount_ = 0;

		int sqlAsyncEnable = (stmt.getResultSetHoldability() == TrafT4ResultSet.HOLD_CURSORS_OVER_COMMIT) ? 1 : 0;
		int inputRowCnt = paramRowCount;
		int maxRowsetSize = stmt.getMaxRows();
		String sqlString = (sql == null) ? stmt.getSQL() : sql;
		int sqlStringCharset = 1;
		int cursorNameCharset = 1;
		int stmtLabelCharset = 1;
		byte[] txId;
		ArrayList clientErrors = new ArrayList();

//3196 - NDCS transaction for SPJ	
//		if (ic_.t4props_.getSPJEnv())
//			txId = getUDRTransaction(this.ic_.getByteSwap());
//		else if (stmt.transactionToJoin != null)
//			txId = stmt.transactionToJoin;
//		else if (stmt.connection_.transactionToJoin != null)
//			txId = stmt.connection_.transactionToJoin;
//		else
//			txId = Bytes.createIntBytes(0, false); // 0 length, no data
		if (stmt.transactionToJoin != null)
			txId = stmt.transactionToJoin;
		else if (stmt.connection_.transactionToJoin != null)
			txId = stmt.connection_.transactionToJoin;
		else
			txId = Bytes.createIntBytes(0, false); // 0 length, no data

		SQL_DataValue_def inputDataValue;
		SQLValueList_def inputValueList = new SQLValueList_def();
		byte[] inputParams = null;

		if (executeAPI == TRANSPORT.SRVR_API_SQLEXECDIRECT) {
			sqlStmtType_ = getSqlStmtType(sql);
			stmt.outputDesc_ = null; // clear the output descriptors
		}

		if (stmt.usingRawRowset_ == true) {
			executeAPI = TRANSPORT.SRVR_API_SQLEXECUTE2;
			inputDataValue = new SQL_DataValue_def();
			inputDataValue.userBuffer = stmt.rowwiseRowsetBuffer_;
			inputDataValue.length = stmt.rowwiseRowsetBuffer_.limit() - 4;

			if (this.sqlQueryType_ == TRANSPORT.SQL_INSERT_RWRS) // use the param values
			{
				try {
					inputRowCnt = Integer.parseInt(paramValues[0].toString());
					maxRowsetSize = Integer.parseInt(paramValues[1].toString());
				} catch (Exception e) {
					throw new SQLException(
							"Error setting inputRowCnt and maxRowsetSize.  Parameters not set or invalid.");
				}
			} else {
				inputRowCnt = paramRowCount - 1;
			}

		} else {
			inputDataValue = fillInSQLValues2(ic_.getLocale(), stmt, inputRowCnt, paramCount, paramValues, clientErrors);

			if (ic_.t4props_.t4Logger_.isLoggable(Level.FINEST) == true) {
				Object p[] = T4LoggingUtilities.makeParams(stmt_.connection_.props_, paramRowCount, paramCount,
						paramValues, queryTimeout, stmt);
				String temp = "invoke ==> Execute2";
				ic_.t4props_.t4Logger_.logp(Level.FINEST, "InterfaceStatement", "execute", temp, p);
			}
		}

		ExecuteReply er = t4statement_.Execute(executeAPI, sqlAsyncEnable, inputRowCnt - clientErrors.size(),
				maxRowsetSize, this.sqlStmtType_, this.stmtHandle_, sqlString, sqlStringCharset, this.cursorName_,
				cursorNameCharset, stmt.stmtLabel_, stmtLabelCharset, inputDataValue, inputValueList, txId,
				stmt.usingRawRowset_);

		if (executeAPI == TRANSPORT.SRVR_API_SQLEXECDIRECT) {
			this.sqlQueryType_ = er.queryType;
		}

		if (clientErrors.size() > 0) {
			if (er.errorList == null)
				er.errorList = (SQLWarningOrError[]) clientErrors.toArray(new SQLWarningOrError[clientErrors.size()]);
			else
				er.errorList = mergeErrors((SQLWarningOrError[]) clientErrors
						.toArray(new SQLWarningOrError[clientErrors.size()]), er.errorList);
		}

		stmt_.result_set_offset = 0;
		rowCount_ = er.rowsAffected;
		
		int numStatus;
		
		if (stmt_.connection_.props_.getDelayedErrorMode())
		{
			if (stmt_._lastCount > 0) {
				numStatus = stmt_._lastCount;
			}
			else {
				numStatus = inputRowCnt;
			}
		}
		else
		{
			numStatus = inputRowCnt;
		}

	    if (numStatus < 1)
	    {
	    	numStatus = 1;
	    }

	    stmt.batchRowCount_ = new int[numStatus];
	    boolean batchException = false;	//3164

	    if (stmt_.connection_.props_.getDelayedErrorMode() && stmt_._lastCount < 1) {
			Arrays.fill(stmt.batchRowCount_, -2); // fill with success
	    } 
	    else if (er.returnCode == TRANSPORT.SQL_SUCCESS || er.returnCode == TRANSPORT.SQL_SUCCESS_WITH_INFO
				|| er.returnCode == TRANSPORT.NO_DATA_FOUND) {
			Arrays.fill(stmt.batchRowCount_, -2); // fill with success

			// if we had errors with valid rowIds, update the array
			if (er.errorList != null)
			{
				for (int i = 0; i < er.errorList.length; i++) {
					int row = er.errorList[i].rowId - 1;
					if (row >= 0 && row < stmt.batchRowCount_.length) {
						stmt.batchRowCount_[row] = -3;
						batchException = true;	//3164
					}
				}
			}

            // Sometimes users may set schema through stmt.exec("set schema xx") instead of
            // conn.setSchema("xx"), so there need to update local schema when it success
            if (this.sqlQueryType_ == TRANSPORT.SQL_SET_SCHEMA) {
                String schema = extractSchema(sqlString);
                System.out.println("extract schema : "+schema);
                ic_.setSchemaDirect(schema);
            }

			// set the statement label if we didnt get one back.
			if (er.stmtLabels == null || er.stmtLabels.length == 0) {
				er.stmtLabels = new String[1];
				er.stmtLabels[0] = stmt.stmtLabel_;
			}

			// get the descriptors from the proper location
			TrafT4Desc[][] desc = null;

			// try from execute data first
			if (er.outputDesc != null && er.outputDesc.length > 0) {
				desc = new TrafT4Desc[er.outputDesc.length][];

				for (int i = 0; i < er.outputDesc.length; i++) {
					desc[i] = InterfaceStatement.NewDescArray(er.outputDesc[i]);
				}
			}
			// try from the prepare data
			else if (stmt.outputDesc_ != null && stmt.outputDesc_.length > 0) {
				desc = new TrafT4Desc[1][];
				desc[0] = stmt.outputDesc_;
			}

			if (sqlQueryType_ == TRANSPORT.SQL_CALL_NO_RESULT_SETS ||
					sqlQueryType_ == TRANSPORT.SQL_CALL_WITH_RESULT_SETS) {
				TrafT4CallableStatement cstmt = (TrafT4CallableStatement) stmt;
				Object[] outputValueArray;
				if(er.returnCode == TRANSPORT.NO_DATA_FOUND) { //this should really only happen with LAST0 specified
					if (null != cstmt.outputDesc_) {
					    outputValueArray = new Object[cstmt.outputDesc_.length];
					} else {
					    outputValueArray = null;
					}
				}
				else {
					outputValueArray = InterfaceResultSet.getExecute2Outputs(cstmt.connection_, cstmt.outputDesc_, 
						er.outValues, this.ic_.getByteSwap());
				}
				
				cstmt.setExecuteCallOutputs(outputValueArray, (short) er.rowsAffected);
				stmt.setMultipleResultSets(er.numResultSets, desc, er.stmtLabels, er.proxySyntax);
			} else {
				// fix until we start returning numResultsets for more than just
				// SPJs
				if (desc != null && desc.length > 0 && er.numResultSets == 0) {
					er.numResultSets = 1;
				}

				if (er.outValues != null && er.outValues.length > 0) {
					stmt.setExecute2Outputs(er.outValues, (short) er.rowsAffected, false, er.proxySyntax, desc[0]);
				} else {
					stmt.setMultipleResultSets(er.numResultSets, desc, er.stmtLabels, er.proxySyntax);
				}
			}
			if (er.errorList != null) {
				TrafT4Messages.setSQLWarning(stmt_.connection_.props_, stmt, er.errorList);
			}
		} else {
			Arrays.fill(stmt.batchRowCount_, -3); // fill with failed
			TrafT4Messages.throwSQLException(stmt_.connection_.props_, er.errorList);
		}
	    //3164
	    if (batchException) {
	    	TrafT4Messages.throwSQLException(stmt_.connection_.props_, er.errorList);
	    }
	}

    private String extractSchema(String sqlString) {
        String schemaRegex = "(SET)\\s+(SCHEMA)\\s+([a-zA-Z0-9]+\\s*\\.)\\s*([a-zA-Z0-9]+)\\s*";
        Pattern pattern = Pattern.compile(schemaRegex);
        Matcher m = pattern.matcher(sqlString.toUpperCase());
        while (m.find()) {
            return m.group(m.groupCount());
        }
        return "";
    }

} // end class InterfaceStatement